com.phasmidsoftware.lascala

Created by scalaprof on 5/30/16.

Attributes

Members list

Packages

Created by scalaprof on 7/12/16.

Created by scalaprof on 7/12/16.

Attributes

Created by scalaprof on 11/12/16.

Created by scalaprof on 11/12/16.

Attributes

Created by scalaprof on 11/12/16.

Created by scalaprof on 11/12/16.

Attributes

Created by scalaprof on 1/4/17.

Created by scalaprof on 1/4/17.

Attributes

Type members

Classlikes

trait ActorLike[T] extends Agent[T], Queryable[T], AutoCloseable

The purpose of this trait is to capture the behavior of a class which delegates to an actor (façade or proxy pattern). This is required, for example, when plugging in a technology that behaves as an actor, while wishing to preserve the option of depending on the technology directly (via a façade).

The purpose of this trait is to capture the behavior of a class which delegates to an actor (façade or proxy pattern). This is required, for example, when plugging in a technology that behaves as an actor, while wishing to preserve the option of depending on the technology directly (via a façade).

Created by scalaprof on 9/23/16.

Type parameters

T

the underlying type

Attributes

Supertypes
trait AutoCloseable
trait Queryable[T]
trait Agent[T]
trait PartialFunction[T, Unit]
trait T => Unit
class Object
trait Matchable
class Any
Show all
trait Agent[T] extends PartialFunction[T, Unit]

This trait behaves as a partial function that takes a T as input and returns Unit (i.e nothing). Thus it is (almost) the exact equivalent of Akka's Actor.Receive type.

This trait behaves as a partial function that takes a T as input and returns Unit (i.e nothing). Thus it is (almost) the exact equivalent of Akka's Actor.Receive type.

Type parameters

T

the underlying type

Attributes

Supertypes
trait PartialFunction[T, Unit]
trait T => Unit
class Object
trait Matchable
class Any
Known subtypes
trait ActorLike[T]
class And[T](r1: Rule[T], r2: => Rule[T]) extends BaseRule[T]

"And" sub-class of Rule giving the conjunction of r1 and r2. Not a case class so that we can have a call-by-name parameter

"And" sub-class of Rule giving the conjunction of r1 and r2. Not a case class so that we can have a call-by-name parameter

Type parameters

T

the underlying type of this Rule

Value parameters

r1

the rule which is always evaluated

r2

the rule which may not be evaluated

Attributes

Supertypes
class BaseRule[T]
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Show all
abstract class BaseRule[T](name: String) extends Rule[T]

Attributes

Supertypes
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Known subtypes
class And[T]
class BoundPredicate[T]
class InvalidRule[T]
class Or[T]
class Truth[T]
abstract class BaseVersion[V, Repr](v: V)(using evidence$1: Incrementable[V]) extends Subversioned[V]

Abstract class which extends Subversioned with Ordering. It defines the following behavior: (1) the apply method yields the value of v; (2) the compare method yields the comparison of this and that.

Abstract class which extends Subversioned with Ordering. It defines the following behavior: (1) the apply method yields the value of v; (2) the compare method yields the comparison of this and that.

Type parameters

V

the underlying type of the Subversioned, which is defined to implement Ordering

Value parameters

v

the value of this Subversioned

Attributes

Supertypes
trait Subversioned[V]
trait Ordering[Subversioned[V]]
trait PartialOrdering[Subversioned[V]]
trait Equiv[Subversioned[V]]
trait Serializable
trait Comparator[Subversioned[V]]
trait () => V
class Object
trait Matchable
class Any
Show all
Known subtypes
class Version[V]
class BoundPredicate[T](t: => T, p: => Predicate[T]) extends BaseRule[T]

Bound predicate sub-class of Rule giving the result of applying a parameter to a predicate. Not a case class so that we can have a call-by-name parameter

Bound predicate sub-class of Rule giving the result of applying a parameter to a predicate. Not a case class so that we can have a call-by-name parameter

Value parameters

p

the Predicate

t

the parameter

Attributes

Supertypes
class BaseRule[T]
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Show all
Self type
object Counter

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Counter.type
trait Counter[X] extends Orderable[X]

Type class Counter. An extension of Orderable with the ability to increment the value.

Type class Counter. An extension of Orderable with the ability to increment the value.

Note: this is similar to Incrementable

This combination of trait Counter and implicit objects comprises the "type class" Counter.

Attributes

Companion
object
Supertypes
trait Orderable[X]
trait Ordering[X]
trait PartialOrdering[X]
trait Equiv[X]
trait Serializable
trait Comparator[X]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait IntCounter
object intCounter
trait LongCounter
object longCounter
case class DoubleRNG(n: Long) extends RNG_Java[Double]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class RNG_Java[Double]
trait RNG[Double]
trait () => Double
class Object
trait Matchable
class Any
Show all
object Factorial

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Factorial.type
case class GaussianRNG(n: Long) extends RNG_Java[(Double, Double)]

This class is a random-number-generator for values which are normally distributed with mean: 0 and standard deviation: 1

This class is a random-number-generator for values which are normally distributed with mean: 0 and standard deviation: 1

See Generating values from normal distribution (Box-Muller method)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class RNG_Java[(Double, Double)]
trait RNG[(Double, Double)]
trait () => (Double, Double)
class Object
trait Matchable
class Any
Show all
object GaussianRNG

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class IncrementableSequential[T](t: T, isSnapshot: Boolean = ..., by: String = ...)(using evidence$1: Incrementable[T]) extends OrderedSequential[IncrementableSequential[T]]

This is a simple implementation of the Sequential trait which does not allow for sub-versions.

This is a simple implementation of the Sequential trait which does not allow for sub-versions.

Type parameters

T

the underlying type of this Sequential: it is defined that there exist an implicit value of Incrementable[T] available -- in practice, this typically means an integer of some sort, as String or a LocalDate.

Value parameters

by

the unit of the increment

isSnapshot

(defaults to false) true if this is a snapshot

t

the value of this IncrementalSequential

Attributes

Supertypes
trait Product
trait Equals
trait Ordered[IncrementableSequential[T]]
trait Comparable[IncrementableSequential[T]]
trait Ordering[IncrementableSequential[T]]
trait PartialOrdering[IncrementableSequential[T]]
trait Equiv[IncrementableSequential[T]]
trait Serializable
trait Comparator[IncrementableSequential[T]]
class Object
trait Matchable
class Any
Show all
case class InvalidRule[T](x: Throwable) extends BaseRule[T]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class BaseRule[T]
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Show all
object Kleenean

Companion object to Kleenean

Companion object to Kleenean

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Kleenean.type
case class Kleenean(value: Option[Boolean]) extends Maybe

This is the Kleenean case class which extends Maybe

This is the Kleenean case class which extends Maybe

Value parameters

value

the Option[Boolean] value

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
trait Maybe
trait () => Option[Boolean]
class Object
trait Matchable
class Any
Show all
Known subtypes
object ^^
final case class Layout(tab: Int => String = ..., maxElements: Option[Int] = ..., bookends: String = ...)

How a rendering is laid out.

How a rendering is laid out.

Value parameters

bookends

the prefix, separator and suffix of a collection (by default, "(,)")

maxElements

the maximum number of elements of a collection to be rendered (by default, 10)

tab

the white space for a given indent (by default, two spaces per tab). Typically this will be uniform, but you're free to set up a series of tabs like on an old typewriter where the spacing is non-uniform.

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Layout

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Layout.type
case class Lift[V, T](f: V => T) extends V => Try[T]

Class which is a V=>Try[T] function and which is lifted from the parameter f, a V=>T function

Class which is a V=>Try[T] function and which is lifted from the parameter f, a V=>T function

Type parameters

T

the underlying type of the resulting Try

V

the type of the input parameter

Value parameters

f

the function which converts a V into a T

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait V => Try[T]
class Object
trait Matchable
class Any
Show all
case class LiftMatch[T](f: PartialFunction[Any, T]) extends TrialBase[Any, T]

LiftMatch class which can be composed leftwards or rightwards with functions (including other TrialBase object) Note that anywhere you can right LiftMatch(f), you could, in theory, write Trial(Lift(f)) but in practice it can be tricky so this definition remains for more convenience.

LiftMatch class which can be composed leftwards or rightwards with functions (including other TrialBase object) Note that anywhere you can right LiftMatch(f), you could, in theory, write Trial(Lift(f)) but in practice it can be tricky so this definition remains for more convenience.

Type parameters

T

the underlying type of the resulting Try

Value parameters

f

the partial function which, when applied to the input parameter of type Any, will yield a T

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class TrialBase[Any, T]
trait Any => Try[T]
class Object
trait Matchable
class Any
Show all
case class LiftTrial[V, T](f: V => T) extends TrialBase[V, T]

LiftTrial class which can be composed leftwards or rightwards with functions (including other TrialBase object). Note that anywhere you can right LiftTrial(f), you could, more simply, write Trial(Lift(f))

LiftTrial class which can be composed leftwards or rightwards with functions (including other TrialBase object). Note that anywhere you can right LiftTrial(f), you could, more simply, write Trial(Lift(f))

Type parameters

T

the underlying type of the resulting Try

V

the type of the input parameter

Value parameters

f

the function which, when applied to the input parameter of type V, will yield a T

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class TrialBase[V, T]
trait V => Try[T]
class Object
trait Matchable
class Any
Show all
object LongRNG

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
LongRNG.type
case class LongRNG(n: Long) extends RNG_Java[Long]

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class RNG_Java[Long]
trait RNG[Long]
trait () => Long
class Object
trait Matchable
class Any
Show all
case class Match[T](f: PartialFunction[Any, Try[T]]) extends TrialBase[Any, T]

Match class which can be composed leftwards or rightwards with functions (including other TrialBase object)

Match class which can be composed leftwards or rightwards with functions (including other TrialBase object)

Type parameters

T

the underlying type of the resulting Try

Value parameters

f

the partial function which, when applied to the input parameter of type Any, will yield a Try[T]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class TrialBase[Any, T]
trait Any => Try[T]
class Object
trait Matchable
class Any
Show all
trait Maybe extends () => Option[Boolean]

This trait is to support Kleenean algebra, potentially in a disjunctive or conjunctive expression. The truth-tables for Kleenean logic can be found here: See https://en.wikipedia.org/wiki/Three-valued_logic#Logics Or you can look at KleeneanSpec to see what the rules are.

This trait is to support Kleenean algebra, potentially in a disjunctive or conjunctive expression. The truth-tables for Kleenean logic can be found here: See https://en.wikipedia.org/wiki/Three-valued_logic#Logics Or you can look at KleeneanSpec to see what the rules are.

Attributes

Companion
object
Supertypes
trait () => Option[Boolean]
class Object
trait Matchable
class Any
Known subtypes
class Kleenean
object ^^
object Maybe

Companion object to Maybe

Companion object to Maybe

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Maybe.type
class NoMatchingTrialException(s: String) extends Exception

Attributes

Supertypes
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
class Or[T](r1: Rule[T], r2: => Rule[T]) extends BaseRule[T]

"Or" sub-class of Rule giving the disjunction of r1 and r2. Not a case class so that we can have a call-by-name parameter

"Or" sub-class of Rule giving the disjunction of r1 and r2. Not a case class so that we can have a call-by-name parameter

Type parameters

T

the underlying type of this Rule

Value parameters

r1

the rule which is always evaluated

r2

the rule which may not be evaluated

Attributes

Supertypes
class BaseRule[T]
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Show all
trait OrderedSequential[T] extends Sequential[T], Ordering[T], Ordered[T]

Ordered version of the Sequential trait. We explicitly implement Ordered[T] in addition to Ordering[T]. It would be quite possible to do comparisons using implicit conversions, but this does make things easier.

Ordered version of the Sequential trait. We explicitly implement Ordered[T] in addition to Ordering[T]. It would be quite possible to do comparisons using implicit conversions, but this does make things easier.

Type parameters

T

the underlying type of this Sequential

Attributes

Supertypes
trait Ordered[T]
trait Comparable[T]
trait Ordering[T]
trait PartialOrdering[T]
trait Equiv[T]
trait Serializable
trait Comparator[T]
trait Sequential[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Queryable[T]

This trait behaves exactly as the query method does in an actor but takes a query which is a T

This trait behaves exactly as the query method does in an actor but takes a query which is a T

Type parameters

T

the underlying type

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait ActorLike[T]
object Quicksort

With appreciation to evan058 at StackOverflow See http://stackoverflow.com/questions/41420645/scala-make-function-polymorphic-in-data-structure-type

With appreciation to evan058 at StackOverflow See http://stackoverflow.com/questions/41420645/scala-make-function-polymorphic-in-data-structure-type

NOTE: this is an example of using Factory (formerly CanBuildFrom) to rebuild the original collection type

Created by scalaprof on 1/1/17.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Quicksort.type
trait RNG[+A] extends () => A

Very primitive implementation of a state-based random number generator

Very primitive implementation of a state-based random number generator

CONSIDER reworking this entire package, particularly using map instead of defining things like DoubleRNG.

CONSIDER having RNG extend FilterMonadic or at least implement flatMap

Type parameters

A

the underlying type of this Random Number Generator

Attributes

Companion
object
Supertypes
trait () => A
class Object
trait Matchable
class Any
Known subtypes
class RNG_Java[A]
class DoubleRNG
class GaussianRNG
class LongRNG
object RNG

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
RNG.type
abstract class RNG_Java[+A](n: Long, f: Long => A) extends RNG[A]

An abstract base class which implements some of the basic functionality of RNG

An abstract base class which implements some of the basic functionality of RNG

Type parameters

A

the underlying type of this Random Number Generator

Value parameters

n

the Long value which defines this state of the RNG

Attributes

Companion
object
Supertypes
trait RNG[A]
trait () => A
class Object
trait Matchable
class Any
Known subtypes
class DoubleRNG
class GaussianRNG
class LongRNG
Self type
object RNG_Java

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
RNG_Java.type
object Recursion

Created by scalaprof on 11/9/16.

Created by scalaprof on 11/9/16.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Recursion.type
trait Renderable[A]

Type class to render an A in a human-legible manner (as an alternative to toString), with nested structures indented according to the Layout.

Type class to render an A in a human-legible manner (as an alternative to toString), with nested structures indented according to the Layout.

Instances for the common types are in the companion object; a case class, sealed trait or enum can write derives Renderable.

NOTE: implementations of render may invoke toString, but toString may NOT call render.

Type parameters

A

the type to be rendered

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Renderable

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Renderable.type
object Rule

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Rule.type
sealed trait Rule[T] extends () => Try[Boolean]

Trait Rule which extends ()=>Boolean. An alternative name might be TruthValue or just Truth.

Trait Rule which extends ()=>Boolean. An alternative name might be TruthValue or just Truth.

Thus the apply method for a Rule will always return true or false, with no input parameter.

A (leaf) rule is essentially an expression of the form: variable predicate where predicate is an operator followed by an expression.

A rule can be represented for any type T, including String. However, if you want to be able to evaluate the truth value of a rule, then either (1) T extends Valuable, or (2) an implicit map from String to T is made available

Type parameters

T

the underlying type of this Rule

Attributes

Companion
object
Supertypes
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Known subtypes
class BaseRule[T]
class And[T]
class BoundPredicate[T]
class InvalidRule[T]
class Or[T]
class Truth[T]
Show all
Self type
Rule[T]
class RuleException(s: String) extends Exception

Attributes

Supertypes
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
trait Sequential[T]

This trait defines the concept of something which is part of a sequence, i.e. something which has a next instance.

This trait defines the concept of something which is part of a sequence, i.e. something which has a next instance.

Created by scalaprof on 7/11/17.

Type parameters

T

the underlying type of this Sequential NOTE: once Dotty comes out, we may be able to require that T implement Ordering right here.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case class Shuffle[A](seed: Long) extends Seq[A] => Seq[A]

Case class for shuffling a sequence.

Case class for shuffling a sequence.

NOTE: we do not use RNG here because Random includes a shuffle method. But we can get our seed from a RNG[Long]

Type parameters

A

the underlying type of the Seq to shuffle

Value parameters

seed

the seed for the random number generator

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait Seq[A] => Seq[A]
class Object
trait Matchable
class Any
Show all
trait Subversionable[T]

Trait which defines a Stream of subversions based on this instance of Subversionable.

Trait which defines a Stream of subversions based on this instance of Subversionable.

Type parameters

T

the underlying type

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Version[V]
trait Subversioned[V] extends () => V, Ordering[Subversioned[V]]

Trait which represents a version value (V) which can be sub-versioned. Instances of this trait can be ordered so that they can be compared.

Trait which represents a version value (V) which can be sub-versioned. Instances of this trait can be ordered so that they can be compared.

Type parameters

V

the underlying type of this Subversioned object. Typically, this will be a String or an integral value such as Long.

Attributes

Supertypes
trait Ordering[Subversioned[V]]
trait PartialOrdering[Subversioned[V]]
trait Equiv[Subversioned[V]]
trait Serializable
trait Comparator[Subversioned[V]]
trait () => V
class Object
trait Matchable
class Any
Show all
Known subtypes
class BaseVersion[V, Repr]
class Version[V]
object Trial

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Trial.type
case class Trial[V, T](f: V => Try[T]) extends TrialBase[V, T]

Trial class which can be composed leftwards or rightwards with functions (including other Trial or Match object and even LiftTrial and LiftMatch objects)

Trial class which can be composed leftwards or rightwards with functions (including other Trial or Match object and even LiftTrial and LiftMatch objects)

Type parameters

T

the underlying type of the resulting Try

V

the type of the input parameter

Value parameters

f

the function which, when applied to the input parameter of type V, will yield a Try[T]

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class TrialBase[V, T]
trait V => Try[T]
class Object
trait Matchable
class Any
Show all
abstract class TrialBase[V, T](f: V => Try[T]) extends V => Try[T]

Abstract base class for Trial, Match, LiftTrial and LiftMatch

Abstract base class for Trial, Match, LiftTrial and LiftMatch

Type parameters

T

the underlying type of the resulting Try

V

the type of the input parameter

Value parameters

f

the function which, when applied to the input parameter of type V, will yield a Try[T]

Attributes

Supertypes
trait V => Try[T]
class Object
trait Matchable
class Any
Known subtypes
class LiftMatch[T]
class LiftTrial[V, T]
class Match[T]
class Trial[V, T]
case class Truth[T](b: Boolean) extends BaseRule[T]

This sub-class of Rule simply yields a fixed boolean expression

This sub-class of Rule simply yields a fixed boolean expression

Type parameters

T

the underlying type of this Rule

Value parameters

b

the fixed boolean expression

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class BaseRule[T]
trait Rule[T]
trait () => Try[Boolean]
class Object
trait Matchable
class Any
Show all
object UniformDouble

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class UniformDouble(x: Double)

This is essentially a wrapper of Double where (implicitly) 0 <= x <= 1. Note that we would like to specify a require statement but such are not legal in Value types

This is essentially a wrapper of Double where (implicitly) 0 <= x <= 1. Note that we would like to specify a require statement but such are not legal in Value types

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class UniformDoubleRNG(n: Long) extends RNG_Java[UniformDouble]

This class is a random-number-generator for values uniformly distributed in the range 0..1

This class is a random-number-generator for values uniformly distributed in the range 0..1

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
trait () => UniformDouble
class Object
trait Matchable
class Any
Show all
object Version

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
Version.type
case class Version[V](v: V, subversion: Option[Subversioned[V]], isSnapshot: Boolean = ...)(using evidence$1: Incrementable[V]) extends BaseVersion[V, Version[V]], Sequential[Version[V]], Subversionable[Version[V]]

Case class Version provides a means of labeling something such that different versions can be compared. As in the real world, a Version can consist of just one V tag: or a Version can (optionally) be extended by another Version. This allows for versions of the form 1.1.2 or A.B.B. You cannot currently mix these V types.

Case class Version provides a means of labeling something such that different versions can be compared. As in the real world, a Version can consist of just one V tag: or a Version can (optionally) be extended by another Version. This allows for versions of the form 1.1.2 or A.B.B. You cannot currently mix these V types.

Created by scalaprof on 8/2/16. Updated by scalaprof on 7/11/17.

Attributes

Companion
object
Supertypes
trait Product
trait Equals
trait Sequential[Version[V]]
class BaseVersion[V, Version[V]]
trait Subversioned[V]
trait Ordering[Subversioned[V]]
trait PartialOrdering[Subversioned[V]]
trait Equiv[Subversioned[V]]
trait Serializable
trait Comparator[Subversioned[V]]
trait () => V
class Object
trait Matchable
class Any
Show all
case class VersionException(s: String) extends Exception

Attributes

Supertypes
trait Product
trait Equals
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
trait Versioned[V]

Trait Versioned models something which has a version

Trait Versioned models something which has a version

Type parameters

V

the underlying type of this object's version

Attributes

Supertypes
class Object
trait Matchable
class Any
object ^^ extends Kleenean

This case object is the None version of Maybe. It is used for the bookends of a dis/conjunctive expression of Maybes. But be careful, you need to understand the rules of Kleenean logic with regard to None combining with true or false.

This case object is the None version of Maybe. It is used for the bookends of a dis/conjunctive expression of Maybes. But be careful, you need to understand the rules of Kleenean logic with regard to None combining with true or false.

Attributes

Supertypes
class Kleenean
trait Serializable
trait Product
trait Equals
trait Maybe
trait () => Option[Boolean]
class Object
trait Matchable
class Any
Show all
Self type
^^.type

Types

type Predicate[T] = Predicate[T]