LibAcc: 0.5909=13/22, ProjAcc: 1.0000=0/0, Missing: 102

Module: src/index

Module: src/monad

type 𝓟[ty]540{Monoid} = {mempty: 𝓟[ty]540{Monoid}, mappend: (𝓟[ty]540{Monoid})->𝓟[ty]540{Monoid}, mconcat: (𝓛[ty]8670{Array})->𝓟[ty]540{Monoid}}
type 𝓟[ty]530{Functor} = {fmap: (((any)->any))->𝓟[ty]530{Functor}, lift: (((any)->any))->𝓟[ty]530{Functor}, map: (((any)->any))->𝓟[ty]530{Functor}}
type 𝓟[ty]533{Monad} = {unit: (any)->𝓟[ty]533{Monad}, bind: (((any)->𝓟[ty]533{Monad}))->𝓟[ty]533{Monad}, of: (any)->𝓟[ty]533{Monad}, chain: (((any)->𝓟[ty]533{Monad}))->𝓟[ty]533{Monad}}
type 𝓟[ty]537{MonadPlus} extends 𝓟[ty]533{Monad} = {mzero: 𝓟[ty]533{Monad}, mplus: (𝓟[ty]533{Monad})->𝓟[ty]533{Monad}}
type 𝓟[ty]542{Eq} = {equals: (any)->𝓛[ty]8666{Boolean}}
function 𝓟6{eq} (𝓟7{a}: [OOV]any,𝓟8{b}: [OOV]any): (𝓟9: [OOV]any)
{
 let 𝓟10{idx}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 if (𝓟7{a}.EqualsEqualsEqualsToken(𝓟8{b}))
 {
 return 𝓟9 = 𝓛8744{Boolean}
 }
 if (𝓛12550{$TypeOf}(𝓟7{a}.equals).EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 return 𝓟9 = 𝓟7{a}.equals(𝓟8{b})
 }
 if (𝓟7{a}.length.GreaterThanToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟7{a}.length.EqualsEqualsEqualsToken(𝓟8{b}.length)))
 {
 {
 while (𝓟10{idx}.FirstBinaryOperator(𝓟7{a}.length))
 {
 {
 if (𝓛12548{ExclamationToken}(𝓟6{eq}(𝓟7{a}.access(𝓟10{idx}),𝓟8{b}.access(𝓟10{idx}))))
 {
 return 𝓟9 = 𝓛8744{Boolean}
 }
 }
 𝓟10{idx}.FirstCompoundAssignment(𝓛8745{Number})
 }
 }
 return 𝓟9 = 𝓛8744{Boolean}
 }
 return 𝓟9 = 𝓛8744{Boolean}
}

Module: src/writer

type 𝓟[ty]535{WriterPatterns} = {writer: (𝓛[ty]8670{Array},any)->any}
function 𝓟12{writer} (𝓟13{story}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟14{value}: [OOV]any): (𝓟15: [OOV]𝓟[ty]29{Writer})
{
 return 𝓟15 = 𝓟22{writer}(𝓟13{story},𝓟14{value})
}
function 𝓟16{CONSTRUCTOR} (𝓟17{story}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array}),𝓟18{value}: [OOV]any): (𝓟[ty]29{Writer})
{
 const 𝓟[ty]29{Writer};
 const 𝓟[ty]29{Writer};
 𝓟[ty]29{Writer}.chain ⟵ 𝓟[ty]29{Writer}.bind;
 𝓟[ty]29{Writer}.of ⟵ 𝓟[ty]29{Writer}.unit;
 𝓟[ty]29{Writer}.lift ⟵ 𝓟[ty]29{Writer}.fmap;
 𝓟[ty]29{Writer}.map ⟵ 𝓟[ty]29{Writer}.fmap;
}
function 𝓟22{writer} (𝓟23{story}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟24{value}: [OOV]any): (𝓟25: [OOV]𝓟[ty]29{Writer})
{
 return 𝓟25 = 𝓟16{CONSTRUCTOR}(𝓟23{story},𝓟24{value})
}
function 𝓟26{tell} (𝓟27{s}: [OOV]any): (𝓟28: [OOV]𝓟[ty]29{Writer})
{
 return 𝓟28 = 𝓟16{CONSTRUCTOR}(𝓛8757{Array}(𝓟27{s}),𝓛8745{Number})
}
class 𝓟[ty]29{Writer} extends 𝓟[ty]533{Monad}{
 𝓟31{of}: [miss]𝓛[ty]8696{Function};
 𝓟32{chain}: [miss]𝓛[ty]8696{Function};
 𝓟33{lift}: [miss]𝓛[ty]8696{Function};
 𝓟34{map}: [miss]𝓛[ty]8696{Function};
 function 𝓟52{equals} (𝓟53{other}: [OOV]𝓟[ty]29{Writer}): (𝓟54: [miss]𝓛[ty]8666{Boolean})
 {
 let 𝓟55{i}: 𝓛[ty]8655{Number};
 let 𝓟56{sameStory}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 {
 𝓟55{i}.FirstAssignment(𝓛8745{Number})
 while (𝓟55{i}.FirstBinaryOperator(𝓟[ty]29{Writer}.story.length))
 {
 {
 𝓟56{sameStory} ⟵ 𝓟56{sameStory}.AmpersandAmpersandToken(𝓟[ty]29{Writer}.story.access(𝓟55{i}).EqualsEqualsEqualsToken(𝓟53{other}.story.access(𝓟55{i})));
 }
 𝓟55{i}.FirstCompoundAssignment(𝓛8745{Number})
 }
 }
 return 𝓟54 = 𝓟56{sameStory}.AmpersandAmpersandToken(𝓟[ty]29{Writer}.value.EqualsEqualsEqualsToken(𝓟53{other}.value))
 }
 function 𝓟43{fmap} (𝓟44{f}: 𝓛[ty]8696{Function}): (𝓟45: [OOV]𝓟[ty]29{Writer})
 {
 function 𝓟46{$Lambda13} (𝓟47{v}): (𝓟48: [OOV]𝓟[ty]29{Writer})
 {
 return 𝓟48 = 𝓟[ty]29{Writer}.unit(𝓟44{f}(𝓟47{v}))
 }
 return 𝓟45 = 𝓟[ty]29{Writer}.bind(𝓟46{$Lambda13})
 }
 function 𝓟38{bind} (𝓟39{f}: 𝓛[ty]8696{Function}): (𝓟40: [OOV]𝓟[ty]29{Writer})
 {
 let 𝓟41{wu}: [OOV]𝓟[ty]29{Writer} = 𝓟39{f}(𝓟[ty]29{Writer}.value);
 let 𝓟42{newStory}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]29{Writer}.story.concat(𝓟41{wu}.story);
 return 𝓟40 = 𝓟16{CONSTRUCTOR}(𝓟42{newStory},𝓟41{wu}.value)
 }
 function 𝓟35{unit} (𝓟36{u}: [OOV]any): (𝓟37: [OOV]𝓟[ty]29{Writer})
 {
 return 𝓟37 = 𝓟16{CONSTRUCTOR}(𝓛8757{Array}(),𝓟36{u})
 }
 function 𝓟49{caseOf} (𝓟50{patterns}: [OOV]𝓟[ty]535{WriterPatterns}): (𝓟51: [OOV]any)
 {
 return 𝓟51 = 𝓟50{patterns}.writer(𝓟[ty]29{Writer}.story,𝓟[ty]29{Writer}.value)
 }
}

Module: src/either

type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
type 𝓛[ty]8689{Partial} = 𝓛[ty]8689{Partial}
type 𝓟[ty]526{EitherPatterns} = {left: (any)->any, right: (any)->any}
const 𝓟60{EitherType} = {Left: 𝓛8745{Number},Right: 𝓛8745{Number}};
function 𝓟61{exists} (𝓟62{t}: [OOV]any): (𝓟63: [miss]𝓛[ty]8666{Boolean})
{
 return 𝓟63 = 𝓟62{t}.ExclamationEqualsEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓟62{t}.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
}
function 𝓟64{either} (𝓟65{l}: [OOV]any,𝓟66{r}: [OOV]any): (𝓟67: [OOV]𝓟[ty]81{Either})
{
 if (𝓟61{exists}(𝓟65{l}).AmpersandAmpersandToken(𝓟61{exists}(𝓟66{r})))
 {
 𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
 }
 if (𝓛12548{ExclamationToken}(𝓟61{exists}(𝓟65{l})).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟61{exists}(𝓟66{r}))))
 {
 𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
 }
 if (𝓟61{exists}(𝓟65{l}).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟61{exists}(𝓟66{r}))))
 {
 return 𝓟67 = 𝓟75{left}(𝓟65{l})
 }
 if (𝓛12548{ExclamationToken}(𝓟61{exists}(𝓟65{l})).AmpersandAmpersandToken(𝓟61{exists}(𝓟66{r})))
 {
 return 𝓟67 = 𝓟78{right}(𝓟66{r})
 }
}
function 𝓟68{CONSTRUCTOR} (𝓟69{type}: 𝓛[ty]8655{Number},𝓟70{l}: [OOV]any,𝓟71{r}: [OOV]any): (𝓟[ty]81{Either})
{
 const 𝓟[ty]81{Either};
 const 𝓟[ty]81{Either};
 𝓟[ty]81{Either}.chain ⟵ 𝓟[ty]81{Either}.bind;
 𝓟[ty]81{Either}.of ⟵ 𝓟[ty]81{Either}.unit;
 𝓟[ty]81{Either}.lift ⟵ 𝓟[ty]81{Either}.fmap;
 𝓟[ty]81{Either}.map ⟵ 𝓟[ty]81{Either}.fmap;
}
function 𝓟75{left} (𝓟76{l}: [OOV]any): (𝓟77: [OOV]𝓟[ty]81{Either})
{
 return 𝓟77 = 𝓟68{CONSTRUCTOR}(𝓟60{EitherType}.Left,𝓟76{l})
}
function 𝓟78{right} (𝓟79{r}: [OOV]any): (𝓟80: [OOV]𝓟[ty]81{Either})
{
 return 𝓟80 = 𝓟68{CONSTRUCTOR}(𝓟60{EitherType}.Right,𝓛12563{undefined},𝓟79{r})
}
class 𝓟[ty]81{Either} extends 𝓟[ty]533{Monad}{
 𝓟83{of}: [miss]𝓛[ty]8696{Function};
 𝓟84{chain}: [miss]𝓛[ty]8696{Function};
 𝓟85{lift}: [miss]𝓛[ty]8696{Function};
 𝓟86{map}: [miss]𝓛[ty]8696{Function};
 function 𝓟114{equals} (𝓟115{other}: [OOV]𝓟[ty]81{Either}): (𝓟116: [OOV]any)
 {
 return 𝓟116 = 𝓟115{other}.type.EqualsEqualsEqualsToken(𝓟[ty]81{Either}.type).AmpersandAmpersandToken(𝓟[ty]81{Either}.type.EqualsEqualsEqualsToken(𝓟60{EitherType}.Left).AmpersandAmpersandToken(𝓟6{eq}(𝓟115{other}.l,𝓟[ty]81{Either}.l)).BarBarToken(𝓟[ty]81{Either}.type.EqualsEqualsEqualsToken(𝓟60{EitherType}.Right).AmpersandAmpersandToken(𝓟6{eq}(𝓟115{other}.r,𝓟[ty]81{Either}.r))))
 }
 function 𝓟117{do} (𝓟118{patterns}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8689{Partial})): (𝓟119: [OOV]𝓟[ty]81{Either})
 {
 function 𝓟120{$Lambda5} (𝓟121{l}: [OOV]any): (𝓟122: [miss]𝓛[ty]10033{Void})
 {
 }
 function 𝓟123{$Lambda6} (𝓟124{r}: [OOV]any): (𝓟125: [miss]𝓛[ty]10033{Void})
 {
 }
 let 𝓟126{noop_pattern}: [miss]𝓛[ty]8642{Object} = {left: 𝓟120{$Lambda5},right: 𝓟123{$Lambda6}};
 let 𝓟127{merged} = 𝓛8741{Object}.assign(𝓟126{noop_pattern},𝓟118{patterns});
 𝓟[ty]81{Either}.caseOf(𝓟127{merged})
 return 𝓟119 = 𝓟[ty]81{Either}
 }
 function 𝓟105{fmap} (𝓟106{f}: 𝓛[ty]8696{Function}): (𝓟107: [OOV]𝓟[ty]81{Either})
 {
 function 𝓟108{$Lambda4} (𝓟109{v}): (𝓟110: [OOV]𝓟[ty]81{Either})
 {
 return 𝓟110 = 𝓟[ty]81{Either}.unit(𝓟106{f}(𝓟109{v}))
 }
 return 𝓟107 = 𝓟[ty]81{Either}.bind(𝓟108{$Lambda4})
 }
 function 𝓟87{isLeft} (): (𝓟88: [miss]𝓛[ty]8666{Boolean})
 {
 function 𝓟89{$Lambda0} (): (𝓟90: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟90 = 𝓛8744{Boolean}
 }
 function 𝓟91{$Lambda1} (): (𝓟92: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟92 = 𝓛8744{Boolean}
 }
 return 𝓟88 = 𝓟[ty]81{Either}.caseOf({left: 𝓟89{$Lambda0},right: 𝓟91{$Lambda1}})
 }
 function 𝓟102{bind} (𝓟103{f}: 𝓛[ty]8696{Function}): (𝓟104: [OOV]𝓟[ty]81{Either})
 {
 return 𝓟104 = (𝓟[ty]81{Either}.type.EqualsEqualsEqualsToken(𝓟60{EitherType}.Right) ? 𝓟103{f}(𝓟[ty]81{Either}.r) : 𝓟75{left}(𝓟[ty]81{Either}.l)
 }
 function 𝓟93{isRight} (): (𝓟94: [miss]𝓛[ty]8666{Boolean})
 {
 function 𝓟95{$Lambda2} (): (𝓟96: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟96 = 𝓛8744{Boolean}
 }
 function 𝓟97{$Lambda3} (): (𝓟98: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟98 = 𝓛8744{Boolean}
 }
 return 𝓟94 = 𝓟[ty]81{Either}.caseOf({left: 𝓟95{$Lambda2},right: 𝓟97{$Lambda3}})
 }
 function 𝓟99{unit} (𝓟100{t}: [OOV]any): (𝓟101: [OOV]𝓟[ty]81{Either})
 {
 return 𝓟101 = 𝓟78{right}(𝓟100{t})
 }
 function 𝓟111{caseOf} (𝓟112{pattern}: [OOV]𝓟[ty]526{EitherPatterns}): (𝓟113: [OOV]any)
 {
 return 𝓟113 = (𝓟[ty]81{Either}.type.EqualsEqualsEqualsToken(𝓟60{EitherType}.Right) ? 𝓟112{pattern}.right(𝓟[ty]81{Either}.r) : 𝓟112{pattern}.left(𝓟[ty]81{Either}.l)
 }
}

Module: src/maybe

type 𝓟[ty]528{MaybePatterns} = {just: (any)->any, nothing: ()->any}
type 𝓛[ty]8689{Partial} = 𝓛[ty]8689{Partial}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
const 𝓟131{MaybeType} = {Nothing: 𝓛8745{Number},Just: 𝓛8745{Number}};
function 𝓟132{maybe} (𝓟133{t}: [OOV]any): (𝓟134: [OOV]𝓟[ty]167{Maybe})
{
 return 𝓟134 = 𝓟153{maybe}(𝓟133{t})
}
function 𝓟135{$Lambda8} (𝓟136{t}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object})): (𝓟137: [OOV]𝓟[ty]167{Maybe})
{
 return 𝓟137 = 𝓟145{sequence}(𝓟136{t})
}
const 𝓟138{all}: [miss]𝓛[ty]8696{Function} = 𝓟135{$Lambda8};
function 𝓟139{CONSTRUCTOR} (𝓟140{type}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟141{value}: [OOV]any): (𝓟[ty]167{Maybe})
{
 const 𝓟[ty]167{Maybe};
 const 𝓟[ty]167{Maybe};
 𝓟[ty]167{Maybe}.chain ⟵ 𝓟[ty]167{Maybe}.bind;
 𝓟[ty]167{Maybe}.of ⟵ 𝓟[ty]167{Maybe}.unit;
 𝓟[ty]167{Maybe}.lift ⟵ 𝓟[ty]167{Maybe}.fmap;
 𝓟[ty]167{Maybe}.map ⟵ 𝓟[ty]167{Maybe}.fmap;
}
function 𝓟145{sequence} (𝓟146{t}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object})): (𝓟147: [OOV]𝓟[ty]167{Maybe})
{
 function 𝓟148{$Lambda7} (𝓟149{k}): (𝓟150: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟150 = 𝓟146{t}.access(𝓟149{k}).type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Nothing)
 }
 if (𝓛8741{Object}.keys(𝓟146{t}).filter(𝓟148{$Lambda7}).length)
 {
 return 𝓟147 = 𝓟159{nothing}()
 }
 let 𝓟151{result}: 𝓛[ty]8642{Object} = {};
 {
 let 𝓟152{k}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟146{t});
 while (𝓛8744{Boolean})
 {
 if (𝓟146{t}.hasOwnProperty(𝓟152{k}))
 {
 𝓟151{result}.access(𝓟152{k}) ⟵ 𝓟146{t}.access(𝓟152{k}).value;
 }
 }
 }
 return 𝓟147 = 𝓟156{just}(𝓟151{result})
}
function 𝓟153{maybe} (𝓟154{t}: [OOV]any): (𝓟155: [OOV]𝓟[ty]167{Maybe})
{
 return 𝓟155 = (𝓟154{t}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓟154{t}.EqualsEqualsEqualsToken(𝓛12563{undefined})) ? 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Nothing) : 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Just,𝓟154{t})
}
function 𝓟156{just} (𝓟157{t}: [OOV]any): (𝓟158: [OOV]𝓟[ty]167{Maybe})
{
 if (𝓟157{t}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓟157{t}.EqualsEqualsEqualsToken(𝓛12563{undefined})))
 {
 𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
 }
 return 𝓟158 = 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Just,𝓟157{t})
}
function 𝓟159{nothing} (): (𝓟160: [OOV]𝓟[ty]167{Maybe})
{
 return 𝓟160 = 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Nothing)
}
function 𝓟161{isJust} (𝓟162{t}: [OOV]𝓟[ty]167{Maybe}): (𝓟163: 𝓛[ty]8666{Boolean})
{
 return 𝓟163 = 𝓟162{t}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Just)
}
function 𝓟164{isNothing} (𝓟165{t}: [OOV]𝓟[ty]167{Maybe}): (𝓟166: 𝓛[ty]8666{Boolean})
{
 return 𝓟166 = 𝓟165{t}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Nothing)
}
class 𝓟[ty]167{Maybe} extends 𝓟[ty]533{Monad}{
 𝓟169{of}: [miss]𝓛[ty]8696{Function};
 𝓟170{chain}: [miss]𝓛[ty]8696{Function};
 𝓟171{lift}: [miss]𝓛[ty]8696{Function};
 𝓟172{map}: [miss]𝓛[ty]8696{Function};
 function 𝓟202{valueOrThrow} (𝓟203{error}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10053{Error})): (𝓟204: [OOV]any)
 {
 if (𝓟[ty]167{Maybe}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Just))
 {
 return 𝓟204 = 𝓟[ty]167{Maybe}.value
 }
 𝓟203{error}.BarBarToken(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
 }
 function 𝓟191{equals} (𝓟192{other}: [OOV]𝓟[ty]167{Maybe}): (𝓟193: [OOV]any)
 {
 return 𝓟193 = 𝓟192{other}.type.EqualsEqualsEqualsToken(𝓟[ty]167{Maybe}.type).AmpersandAmpersandToken(𝓟[ty]167{Maybe}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Nothing).BarBarToken(𝓟6{eq}(𝓟192{other}.value,𝓟[ty]167{Maybe}.value)))
 }
 function 𝓟205{do} (𝓟206{patterns}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8689{Partial})): (𝓟207: [OOV]𝓟[ty]167{Maybe})
 {
 function 𝓟208{$Lambda11} (𝓟209{t}: [OOV]any): (𝓟210: [miss]𝓛[ty]10033{Void})
 {
 }
 function 𝓟211{$Lambda12} (): (𝓟212: [miss]𝓛[ty]10033{Void})
 {
 }
 let 𝓟213{noop_pattern}: [miss]𝓛[ty]8642{Object} = {just: 𝓟208{$Lambda11},nothing: 𝓟211{$Lambda12}};
 let 𝓟214{merged} = 𝓛8741{Object}.assign(𝓟213{noop_pattern},𝓟206{patterns});
 𝓟[ty]167{Maybe}.caseOf(𝓟214{merged})
 return 𝓟207 = 𝓟[ty]167{Maybe}
 }
 function 𝓟179{fmap} (𝓟180{f}: 𝓛[ty]8696{Function}): (𝓟181: [OOV]𝓟[ty]167{Maybe})
 {
 function 𝓟182{$Lambda9} (𝓟183{v}): (𝓟184: [OOV]𝓟[ty]167{Maybe})
 {
 return 𝓟184 = 𝓟[ty]167{Maybe}.unit(𝓟180{f}(𝓟183{v}))
 }
 return 𝓟181 = 𝓟[ty]167{Maybe}.bind(𝓟182{$Lambda9})
 }
 function 𝓟199{valueOrCompute} (𝓟200{defaultValueFunction}: 𝓛[ty]8696{Function}): (𝓟201: [OOV]any)
 {
 return 𝓟201 = (𝓟[ty]167{Maybe}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Just) ? 𝓟[ty]167{Maybe}.value : 𝓟200{defaultValueFunction}()
 }
 function 𝓟176{bind} (𝓟177{f}: 𝓛[ty]8696{Function}): (𝓟178: [OOV]𝓟[ty]167{Maybe})
 {
 return 𝓟178 = (𝓟[ty]167{Maybe}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Just) ? 𝓟177{f}(𝓟[ty]167{Maybe}.value) : 𝓟159{nothing}()
 }
 function 𝓟188{defaulting} (𝓟189{defaultValue}: [OOV]any): (𝓟190: [OOV]𝓟[ty]167{Maybe})
 {
 return 𝓟190 = 𝓟156{just}(𝓟[ty]167{Maybe}.valueOr(𝓟189{defaultValue}))
 }
 function 𝓟173{unit} (𝓟174{u}: [OOV]any): (𝓟175: [OOV]𝓟[ty]167{Maybe})
 {
 return 𝓟175 = 𝓟153{maybe}(𝓟174{u})
 }
 function 𝓟194{valueOr} (𝓟195{defaultValue}: [OOV]any): (𝓟196: [OOV]any)
 {
 function 𝓟197{$Lambda10} (): (𝓟198: [OOV]any)
 {
 return 𝓟198 = 𝓟195{defaultValue}
 }
 return 𝓟196 = 𝓟[ty]167{Maybe}.valueOrCompute(𝓟197{$Lambda10})
 }
 function 𝓟185{caseOf} (𝓟186{patterns}: [OOV]𝓟[ty]528{MaybePatterns}): (𝓟187: [OOV]any)
 {
 return 𝓟187 = (𝓟[ty]167{Maybe}.type.EqualsEqualsEqualsToken(𝓟131{MaybeType}.Just) ? 𝓟186{patterns}.just(𝓟[ty]167{Maybe}.value) : 𝓟186{patterns}.nothing()
 }
}