com.aol.cyclops.lambda.api

Class AsAnyM

java.lang.Object

com.aol.cyclops.lambda.api.AsAnyM

Direct Known Subclasses:

AsAnyMList

public class AsAnyM
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
AsAnyM()

Method Summary

Modifier and Type	Method and Description
static <T> AnyM<T>	anyM(java.util.Collection<T> anyM) Create a Monad wrapper from a Collection Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(java.util.concurrent.CompletableFuture<T> anyM) Create a Monad wrapper from a CompletableFuture Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(java.util.Iterator<T> anyM) Create a Monad wrapper from an Iterator Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(com.nurkiewicz.lazyseq.LazySeq<T> anyM)
static <T> AnyM<T>	anyM(java.util.Optional<T> anyM) Create a Monad wrapper from an Optional Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(java.util.stream.Stream<T> anyM) Create a Monad wrapper from a Stream Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(Streamable<T> anyM) Create a Monad wrapper from a Streamable Create a duck typed Monad wrapper.
static <T> AnyM<T>	anyM(T... values) Create a Monad wrapper from an array of values Create a duck typed Monad wrapper.
static AnyM<java.lang.String>	anyMFromBufferedReader(java.io.BufferedReader anyM) Construct an AnyM backed by a Stream of text from the lines of the BufferedReader
static AnyM<java.lang.Character>	anyMFromCharSequence(java.lang.CharSequence anyM) Construct an AnyM backed by a Stream of Characters from the text of a String
static AnyM<java.lang.String>	anyMFromFile(java.io.File anyM) Construct an AnyM backed by a Stream of text from the lines of the supplied file
static AnyM<java.lang.String>	anyMFromURL(java.net.URL anyM) Construct an AnyM backed by a Stream of text from the lines of the URL
static <T> AnyM<T>	anyMIterable(java.lang.Iterable<T> anyM) Create a Monad wrapper from an Iterable Create a duck typed Monad wrapper.
static <T> AnyM<T>	convertToAnyM(java.lang.Object anyM) Create a Monad wrapper from an Object that will be converted to Monadic form if neccessary by the registered MonadicConverters.
static <T> AnyM<T>	notTypeSafeAnyM(java.lang.Object anyM) Create a duck typed Monad wrapper.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AsAnyM

public AsAnyM()

Method Detail

notTypeSafeAnyM

public static <T> AnyM<T> notTypeSafeAnyM(java.lang.Object anyM)

Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 

we can write

   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(Streamable<T> anyM)

Create a Monad wrapper from a Streamable Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(java.util.stream.Stream<T> anyM)

Create a Monad wrapper from a Stream Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 
  

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(java.util.Optional<T> anyM)

Create a Monad wrapper from an Optional Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Optional<Integer>,Integer> opt;
 
 we can write
 
   AnyM<Integer> opt;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(java.util.concurrent.CompletableFuture<T> anyM)

Create a Monad wrapper from a CompletableFuture Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<CompletableFuture<Integer>,Integer> future;
 
 we can write
 
   AnyM<Integer> future;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)  -- thenApply/Async
 
 flatMap(F<x,MONAD> fm) -- thenCompose/Async
 
 and optionally 
 
 filter(P p)  -- not present for CompletableFutures
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(java.util.Collection<T> anyM)

Create a Monad wrapper from a Collection Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(com.nurkiewicz.lazyseq.LazySeq<T> anyM)

anyMFromFile

public static AnyM<java.lang.String> anyMFromFile(java.io.File anyM)

Construct an AnyM backed by a Stream of text from the lines of the supplied file

anyMFromBufferedReader

public static AnyM<java.lang.String> anyMFromBufferedReader(java.io.BufferedReader anyM)

Construct an AnyM backed by a Stream of text from the lines of the BufferedReader

anyMFromURL

public static AnyM<java.lang.String> anyMFromURL(java.net.URL anyM)

Construct an AnyM backed by a Stream of text from the lines of the URL

anyMFromCharSequence

public static AnyM<java.lang.Character> anyMFromCharSequence(java.lang.CharSequence anyM)

Construct an AnyM backed by a Stream of Characters from the text of a String

anyMIterable

public static <T> AnyM<T> anyMIterable(java.lang.Iterable<T> anyM)

Create a Monad wrapper from an Iterable Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(java.util.Iterator<T> anyM)

Create a Monad wrapper from an Iterator Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad

anyM

public static <T> AnyM<T> anyM(T... values)

Create a Monad wrapper from an array of values Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Returns:

Duck typed Monad

convertToAnyM

public static <T> AnyM<T> convertToAnyM(java.lang.Object anyM)

Create a Monad wrapper from an Object that will be converted to Monadic form if neccessary by the registered MonadicConverters. You can register your own MonadicConverter instances and / or change the priorities of currently registered converters. Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of

  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 

The wrapped Monaad should have equivalent methods for

  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 

A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type

Parameters:

anyM - to wrap

Returns:

Duck typed Monad