Flutter光学处理插件optics的使用

Flutter光学处理插件optics的使用

optics 是一个用于 Dart 的棱镜和透镜包。它允许你查看和修改不可变结构中具有可空值的属性（通过棱镜）或非空值的属性（通过透镜）。

棱镜

棱镜允许你查看和修改不可变结构中具有可空值的属性。

透镜

透镜类似于棱镜，可以让你查看和修改属性，但与棱镜不同的是，透镜的属性被假定为非空值。

使用示例

以下是一个完整的示例，展示了如何使用 optics 包来操作对象的属性。

import 'package:meta/meta.dart';
import 'package:optics/optics.dart';

void main() {
  // 创建一个人的对象
  Person person = Person(
    name: 'Joe',
    address: Address(streetName: '123 Capital of Texas Hwy'),
  );

  // 验证初始地址
  assert(person.address.streetName == '123 Capital of Texas Hwy');

  // Joe 搬家了！
  person = person.addressOptic.compound(AddressOptics.streetName).set(
        '456 Mesa Dr',
      );

  // 验证新的地址
  assert(person.address.streetName == '456 Mesa Dr');

  // Joe 找到了工作！
  person = BoundPrism(source: person, prism: PersonOptics.job).set(
    Job(address: Address(streetName: '789 E 6th St'), title: 'Sales bro'),
  );

  // 验证新工作
  assert(person.job?.title == 'Sales bro');

  // Joe 获得了晋升！
  final personJobTitle = PersonOptics.job.compound(JobOptics.title.asPrism());
  person = personJobTitle.set(person, 'Executive sales bro');

  // 验证新职位
  assert(person.job?.title == 'Executive sales bro');

  // 输出信息
  print('''Howdy, ${person.name}!
You're ${personJobTitle.get(person)?.indefiniteArticle()} ${personJobTitle.get(person)}.
Nice place you've got @ ${person.addressOptic.compound(AddressOptics.streetName)()}.''');
}

// 定义Person类
[@immutable](/user/immutable)
class Person {
  const Person({
    required this.name,
    required this.address,
    this.job,
  });

  final String name;

  final Address address;

  final Job? job;

  Person copyWith({
    String? name,
    Address? address,
    Job? job,
  }) =>
      Person(
        name: name ?? this.name,
        address: address ?? this.address,
        job: job ?? this.job,
      );

  [@override](/user/override)
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is Person &&
          name == other.name &&
          address == other.address &&
          job == other.job;

  [@override](/user/override)
  int get hashCode => Object.hash(name, address, job);
}

// Person扩展
extension PersonOptics on Person {
  static final Lens<Person, Address> address = Lens(
    getter: (subject) => subject.address,
    setter: (subject, value) => subject.copyWith(address: value),
  );

  static final Prism<Person, Job?> job = Prism(
    getter: (subject) => subject.job,
    setter: (subject, value) => subject.copyWith(job: value),
  );

  BoundLens<Person, Address> get addressOptic =>
      BoundLens(source: this, lens: address);

  BoundPrism<Person, Job?> get jobOptic => BoundPrism(source: this, prism: job);
}

// 定义Address类
[@immutable](/user/immutable)
class Address {
  const Address({required this.streetName});

  final String streetName;

  Address copyWith({String? streetName}) => Address(
        streetName: streetName ?? this.streetName,
      );

  [@override](/user/override)
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is Address && streetName == other.streetName;

  [@override](/user/override)
  int get hashCode => streetName.hashCode;
}

// Address扩展
extension AddressOptics on Address {
  static final Lens<Address, String> streetName = Lens(
    getter: (subject) {
      return subject.streetName;
    },
    setter: (subject, value) {
      return subject.copyWith(streetName: value);
    },
  );

  BoundLens<Address, String> get streetNameOptic =>
      BoundLens(source: this, lens: streetName);
}

// 定义Job类
[@immutable](/user/immutable)
class Job {
  Job({
    required this.address,
    required this.title,
  });

  final String title;

  final Address address;

  Job copyWith({String? title, Address? address}) => Job(
        title: title ?? this.title,
        address: address ?? this.address,
      );

  [@override](/user/override)
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is Job && title == other.title && address == other.address;

  [@override](/user/override)
  int get hashCode => Object.hash(title, address);
}

// Job扩展
extension JobOptics on Job {
  static final Lens<Job, String> title = Lens(
    getter: (subject) {
      return subject.title;
    },
    setter: (subject, value) {
      return subject.copyWith(title: value);
    },
  );

  static final Lens<Job, Address> address = Lens(
    getter: (subject) {
      return subject.address;
    },
    setter: (subject, value) {
      return subject.copyWith(address: value);
    },
  );

  BoundLens<Job, String> get titleOptic => BoundLens(source: this, lens: title);

  BoundLens<Job, Address> get addressOptic =>
      BoundLens(source: this, lens: address);
}

// 字符串扩展
extension StringOptics on String {
  BoundLens<String, String> get indefiniteArticle => BoundLens(
        source: this,
        lens: Lens(
          getter: (source) {
            if (source.isEmpty) {
              return source;
            }

            final vowels = ['a', 'e', 'i', 'o', 'u'];

            for (final vowel in vowels) {
              if (source.toLowerCase().startsWith(vowel)) {
                return 'an';
              }
            }

            return 'a';
          },
          setter: (source, value) => value,
        ),
      );
}

// 无用的类
class Nullable {
  const Nullable();
  static const instance = Nullable();
}