assigning None through Optional.fromProp about monocle-ts HOT 6 CLOSED

I've knocked up a PR that makes my change. It should actually be safe to apply, right? Unless it invalidates some laws. This is where things get woolly for me. 😊

from monocle-ts.

Hi,

AFAIK Optionals are not "standard", they are a Monocle thing. Based on the documentation I think that the current implementation is not lawful, I guess should be

/** generate an optional from a type and a prop which is a `Option` */
static fromProp<T extends { [K in P]: Option<any> }, P extends keyof T>(prop: P): Optional<T, T[P]['_A']> {
  return new Optional<T, T[P]['_A']>(
    s => s[prop],
-    (a, s) => Object.assign({}, s, { [prop as any]: some(a) })
+    (a, s) => isSome(s[prop]) ? Object.assign({}, s, { [prop as any]: some(a) }) : s
  )
}

i.e. you cannot insert or delete with an Optional, only modify

from monocle-ts.

Ah. So if want to be able to set something where there was None before, I actually need to use Lens<X, Option<Y>> instead of Optional<X, Y>?

from monocle-ts.

I think so, however is pretty awkward

import { Lens, Optional, Prism } from '../src'
import { Option, some, none } from 'fp-ts/lib/Option'

interface Bar {
  s: Option<string>
}

interface Foo {
  bar: Option<Bar>
}

const foo: Foo = {
  bar: some({
    // s: some('blah')
    s: none
  })
}

const barLens = Lens.fromProp<Foo, 'bar'>('bar')
const sLens = Lens.fromProp<Bar, 's'>('s')

console.log(barLens.modify(obar => obar.map(bar => sLens.set(some('BLAH'), bar)), foo)) // { bar: Some({"s":{"value":"BLAH","_tag":"Some"}}) }

Based on this 3D https://groups.google.com/forum/#!topic/scala-monocle/i7Y4o0I7tIc we could define the some prism

function getSomePrism<A>(): Prism<Option<A>, A> {
  return new Prism<Option<A>, A>(
    s => s,
    a => some(a)
  )
}

const sOptional = barLens.asOptional()
  .compose(getSomePrism<Bar>().asOptional())
  .compose(sLens.asOptional())
  .compose(getSomePrism<string>().asOptional())

console.log(sOptional.set('WHOP', foo)) // { bar: Some({"s":{"value":"WHOP","_tag":"Some"}}) }

Also we could add a bunch of composeX helpers so we can write

const sOptional = barLens
  .composePrism(getSomePrism<Bar>())
  .composeLens(sLens)
  .composePrism(getSomePrism<string>())

as shown in the link

from monocle-ts.

Puts on reading glasses.

Thanks @gcanti !

from monocle-ts.

Trying to read through the comments and related ones in other issues, it does not appear Optional ever got the ability to set its target to none (i.e., clear the target). Was there a reason this wasn't implemented? I don't see discussion here or at #15 mentioning this, just a workaround involving a Lens<State, Option> rather than Optional<State, X>

from monocle-ts.