Question: Struct monoid - boilerplate

[maljac]

Hi,

I am just starting using fp-ts. So please be kind :)

I am trying to solve the "typical configuration merge" problem that one can find in several tutorials. Starting point is the decoding with a io-ts decoder / type.
The code works fine, but it seems "quite a lot of setup code" to me.

type Column = {
  field: string;
  hidden?: boolean;
  layout: {web: {size: number}, mobile?: {size: number}},
  format: 'number' | 'string',
  foo?: string,
  bar?: string
}

const TColumn = t.intersection([
  t.type({
    field: optionFromNullable(t.string),
  }),
  t.partial({
    hidden: withFallback(optionFromNullable(t.boolean), O.some(false)),
    layout: withFallback(optionFromNullable(t.UnknownRecord), O.none)
  })
])

type TTColumn = t.TypeOf<typeof TColumn>;
const TColumnExact = t.exact(TColumn);

export const eitherUnfold: <T>(ma: E.Either<any, T>) => O.Option<T> = E.match(
  (e) => O.none,
  O.some
);

const parse = flow(TColumnExact.decode, eitherUnfold);

const defaultConfiguration: Column = {
  field: 'name',
  layout: {web: {size: 1}},
  format: 'string'
};

const pDefaultConfiguration = parse(defaultConfiguration);
const pRemoteConfiguration = parse({field: "name", hidden: true, foo: 1})

console.log('Default ', pDefaultConfiguration);
console.log('Remote ', pRemoteConfiguration);

const ColumnMonoidStruct: M.Monoid<TTColumn> = M.struct({
  field: O.getMonoid(SG.last()),
  hidden: O.getMonoid(SG.last()),
  layout: O.getMonoid(SG.last())
})

const concat = M.concatAll(O.getMonoid(ColumnMonoidStruct))

const result = flow(
  concat,
  O.map(a => {
    return {
      field: O.toNullable(a.field),
      hidden: O.match(() => false, a => a)(a.hidden),
      layout: O.toNullable(a.layout)
    }
  }),
  O.toNullable,
)([pDefaultConfiguration, pRemoteConfiguration])

console.log(result);

Do I miss something or do I do something wrong here?

More specific questions:

1. Is there a "easier" way to build the ColumnMonoidStruct?
2. Is there a "easier" way to return from Optional-World to normal-World? (see O.map(...))?

[samhh]

1. I don't believe so. TypeScript has no inherent notion of typeclasses so there's a lot of instance-passing like this. On the plus side, this does offer extra flexibility without the need for newtype wrappers.
2. I think there's a problem before you reach this point, your static configuration is being parsed unnecessarily. Here's another approach to consider in which we don't sacrifice the non-nullability of the default:

declare const defCol: Column
declare const extCol: Option<TTColumn>

const mergeCol = (x: Column) => (y: TTColumn): Column => ({
  ...x,
  field: y.field,
  hidden: pipe(y.hidden, O.getOrElse(constant(x.hidden))),
  layout: pipe(y.layout, O.getOrElse(constant(x.layout))),
})

const col: Column = pipe(extCol, O.match(constant(defCol), mergeCol(defCol)))

Some other, minor notes:

• eitherUnfold looks like O.fromOption O.fromEither
• () => x == constant(x)
• x => x == identity
• O.match(f, identity) == O.getOrElse(f)

[maljac]

Thank you! I got your points.

your static configuration is being parsed unnecessarily

Yes. Actually I do this on purpose to be able to concat them. I will probably go for your approach as it is more clear and the concat might be a little bit too much for merging only two objects.

eitherUnfolds

Yes, O.fromEither

Actually I had to do a minor adjustment, because the hidden value is optional. Therefore I added O.alt in mergeCol:

type Column = {
  field: string;
  hidden?: boolean;
  layout: {web: {size: number}, mobile?: {size: number}},
  format: 'number' | 'string',
  foo?: string,
  bar?: string
}

const TRemoteColumn = t.intersection([
  t.type({
    field: optionFromNullable(t.string),
  }),
  t.partial({
    hidden: withFallback(optionFromNullable(t.boolean), O.none),
    layout: withFallback(optionFromNullable(t.UnknownRecord), O.none)
  })
])

type RemoteColumn = t.TypeOf<typeof TRemoteColumn>;
const TRemoteColumnExact = t.exact(TRemoteColumn);

const parse = flow(TRemoteColumnExact.decode, O.fromEither);

const defaultColumn: Column = {
  field: 'name',
  layout: {web: {size: 1}},
  format: 'string',
  foo: '1234'
};

const pRemoteColumn = parse({field: "name", hidden: true, foo: 1, layout: {web: 3}})

const mergeCol = (defaultC: Column) => (remoteC: RemoteColumn): Column => ({
  ...defaultC,
  hidden: pipe(remoteC.hidden, O.alt(constant(O.fromNullable(defaultC.hidden))), O.getOrElse(constant(false))),
  layout: pipe(remoteC.layout, O.getOrElse(constant(defaultC.layout))),
})

const buildCol = (remoteC: O.Option<RemoteColumn>, defaultC: Column): Column => {
  return pipe(
    remoteC,
    O.match(constant(defaultC), mergeCol(defaultC))
  )
}

const finalCol = buildCol(pRemoteColumn, defaultColumn)
console.log(finalCol)