Class Optional<T>

constructor

• new Optional<T>(value: T | null | undefined): Optional<T>

  Type Parameters

  • T

  Parameters

  • value: T | null | undefined

  Returns Optional<T>

Staticabsent

value

• get value(): T

  Returns T

flatMap

• flatMap<R>(fn?: (data: T) => R): Optional<any>

  Type Parameters

  • R

  Parameters

  • Optionalfn: (data: T) => R

  Returns Optional<any>

get

• get<R>(defaultVal?: any): Optional<R>

  convenience function to flatmap the internal value and replace it with a default in case of being absent

  Type Parameters

  • R

  Parameters

  • defaultVal: any = Optional.absent

  Returns Optional<R>

getIf

• getIf<R>(...key: string[]): Optional<R>

  Type Parameters

  • R

  Parameters

  • ...key: string[]

  Returns Optional<R>

getIfPresent

• getIfPresent<R>(key: string): Optional<R>

  additional syntactic sugar which is not part of the usual optional implementation but makes life easier, if you want to sacrifice typesafety and refactoring capabilities in typescript

  Type Parameters

  • R

  Parameters

  • key: string

  Returns Optional<R>

ifPresentLazy

• ifPresentLazy(presentRunnable?: (val?: Optional<T>) => void): Optional<T>

  Parameters

  • presentRunnable: (val?: Optional<T>) => void = ...

  Returns Optional<T>

isAbsent

• isAbsent(): boolean

  Returns boolean

isPresent

• isPresent(presentRunnable?: (val?: Optional<T>) => void): boolean

  any value present

  Parameters

  • OptionalpresentRunnable: (val?: Optional<T>) => void

  Returns boolean

match

• match(fn: (item: T) => boolean): boolean

  simple match, if the first order function call returns true then there is a match, if the value is not present it never matches

  Parameters

  • fn: (item: T) => boolean

    the first order function performing the match

  Returns boolean

orElse

• orElse(elseValue: any): Optional<any>

  Parameters

  • elseValue: any

  Returns Optional<any>

orElseLazy

• orElseLazy(func: () => any): Optional<any>

  lazy, passes a function which then is lazily evaluated instead of a direct value

  Parameters

  • func: () => any

  Returns Optional<any>

resolve

• resolve<V>(resolver: (item: T) => V): Optional<V>

  elvis like typesafe functional save resolver a typesafe option for getIfPresent

  usage myOptional.resolve(value => value.subAttr.subAttr2).orElseLazy(....) if this is resolvable without any errors an Optional with the value is returned if not, then an Optional absent is returned, also if you return Optional absent it is flatmapped into absent

  Type Parameters

  • V

  Parameters

  • resolver: (item: T) => V

    the resolver function, can throw any arbitrary errors, int the error case the resolution goes towards absent

  Returns Optional<V>

toJson

• toJson(): string

  Returns string

StaticfromNullable

• fromNullable<V extends Optional<T>, T>(value?: T | null): Optional<T>

  Type Parameters

  • V extends Optional<T>
  • T

  Parameters

  • Optionalvalue: T | null

  Returns Optional<T>