nee-core

alltypes

class ActiveAsyncClose<R>

ActiveAsyncClose(asyncClean: ActiveAsynStack<R>)
fun closeAsync(env: R): Any?

class ActiveAsynStack<R> : AsyncStack<R>

ActiveAsynStack(parent: AsyncStack<R>, actions: Seq<AsyncClosingAction<R>>)
fun cleanUp(env: R): Pair<AsyncStack<R>, R>
fun closeAsync(env: R): Pair<AsyncStack<R>, R>
fun doOnCleanUp(action: AsyncClosingAction<R>): ActiveAsynStack<R>
val parent: AsyncStack<R>

typealias ANee<R, A> = Nee<R, Any, A>
interface AsyncClosingAction<R>

abstract fun onClose(env: R): R
abstract fun onError(env: R, t: Throwable): R

class AsyncEffect<R : ExecutionContextProvider> : Effect<R, Nothing>, Logging

AsyncEffect(localExecutionContext: Option<ExecutionContext> = Option.none())
val localExecutionContext: Option<ExecutionContext>
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<Nothing, A>, R>

class AsyncEnvWrapper<R> : AsyncSupport<R>, Logging

AsyncEnvWrapper(state: AtomicReference<AsyncStack<R>> = AtomicReference(CleanAsyncStack()))
fun asyncStack(): AsyncStack<R>
fun setAsyncStack(oldState: AsyncStack<R>, newState: AsyncStack<R>): Unit

sealed class AsyncStack<R> : Logging

val actions: Seq<AsyncClosingAction<R>>
abstract fun cleanUp(env: R): Pair<AsyncStack<R>, R>
open fun doOnCleanUp(action: AsyncClosingAction<R>): ActiveAsynStack<R>
open fun enterAsync(): ActiveAsynStack<R>
protected fun performActions(env: R): R

interface AsyncSupport<R>

val asyncResouce: ResourceId<AsyncStack<*>>
abstract fun asyncStack(): AsyncStack<R>
fun <R> initiateAsync(env: R): ActiveAsyncClose<R>
abstract fun setAsyncStack(oldState: AsyncStack<R>, newState: AsyncStack<R>): Unit

class CacheEffect<R, E, P> : Effect<R, E>

CacheEffect(p: P, cacheProvider: CacheProvider)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

interface CacheProvider

abstract fun <K, V> computeIfAbsent(key: K, func: (K) -> V): V

data class ClassReport

ClassReport(className: String, functions: Stream<FunctionReport>)
val className: String
val functions: Stream<FunctionReport>

class CleanAsyncStack<R> : AsyncStack<R>

CleanAsyncStack()
fun cleanUp(env: R): Pair<AsyncStack<R>, R>

data class CodeLocation

CodeLocation(functionName: String? = null, className: String? = null, fileName: String? = null, lineNumber: Int? = null, customInfo: String? = null)
val className: String?
val customInfo: String?
val fileName: String?
val functionName: String?
val lineNumber: Int?
fun toString(): String

object CodeNameFinder

fun findBestStackMatchingCodePlaceName(suggestedStackPosition: Int, stackTraces: Array<StackTraceElement>): CodeLocation
fun guessCodePlaceName(suggestedStackPosition: Int = 3): CodeLocation

class ECProvider : ExecutionContextProvider

ECProvider(ectx: ExecutionContext, localWins: Boolean = true)
fun findExecutionContext(local: Option<ExecutionContext>): ExecutionContext

interface Effect<R, E>

open fun <XE> handleError(handler: (E) -> XE): Effect<R, XE>
abstract fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

class Effects<R1, R2 : R1, E1, E2> : Effect<R2, Either<E1, E2>>

Effects(inner: Effect<R1, E1>, outer: Effect<R2, E2>)
fun <R1, R2 : R1, E1, E2> combine(outer: Effect<R1, E1>, inner: Effect<R2, E2>): Effect<R2, Either<E1, E2>>
fun <A> wrap(f: (R2) -> A): (R2) -> Pair<Out<Either<E1, E2>, A>, R2>

sealed class EntryType

object Begin : EntryType
data class End : EntryType

End(elapsedTime: Long)
val elapsedTime: Long

data class InternalError : EntryType

InternalError(msg: String)
val msg: String
fun toString(): String

object EnvLeaf : FlexibleEnv

fun <T : Any> get(id: ResourceId<T>): Option<T>
fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

interface ExecutionContext

abstract fun <T> execute(f: () -> T): Future<T>

interface ExecutionContextProvider

abstract fun findExecutionContext(local: Option<ExecutionContext>): ExecutionContext

class ExecutorExecutionContext : ExecutionContext, Logging

ExecutorExecutionContext(executor: Executor)
fun <T> execute(f: () -> T): Future<T>

interface FlexibleEnv

fun <reified T : Any> create(id: ResourceId<T>, t: T): FlexibleEnv
fun <reified T : Any> create(t: T): FlexibleEnv
fun empty(): FlexibleEnv
abstract fun <T : Any> get(id: ResourceId<T>): Option<T>
abstract fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

class FlexSecEffect<USER, ROLE> : Effect<FlexibleEnv, SecurityError>

FlexSecEffect(roles: List<ROLE>)
fun <A> wrap(f: (FlexibleEnv) -> A): (FlexibleEnv) -> Pair<Out<SecurityError, A>, FlexibleEnv>

class FlexSecurityProvider<USER, ROLE> : FlexibleEnv, SecurityProvider<USER, ROLE>

FlexSecurityProvider(env: FlexibleEnv)
fun getSecurityContext(): Out<SecurityError, SecurityCtx<USER, ROLE>>

class FlexTxEffect<R> : Effect<FlexibleEnv, TxError>

FlexTxEffect()
fun <A> wrap(f: (FlexibleEnv) -> A): (FlexibleEnv) -> Pair<Out<TxError, A>, FlexibleEnv>

data class FunctionReport

FunctionReport(codeLocation: CodeLocation, invocationCount: Long, totalTime: Long, errorsCount: Long)
val codeLocation: CodeLocation
val errorsCount: Long
val invocationCount: Long
operator fun plus(other: FunctionReport): FunctionReport
val totalTime: Long

class HandleErrorEffect<R, E, E1> : Effect<R, E1>

HandleErrorEffect(innerEffect: Effect<R, E>, handler: (E) -> E1)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E1, A>, R>

class HasteTimeProvider : TimeProvider

HasteTimeProvider(timeSource: TimeSource = Haste.TimeSource.systemTimeSource())
fun getTimeSource(): TimeSource

object InPlaceExecutor : Executor

fun execute(command: Runnable): Unit

data class InvocationAccumulator

InvocationAccumulator(starts: Map<UUID, LogEntry> = HashMap.empty(), reports: HashMap<CodeLocation, FunctionReport> = HashMap.empty())
fun addLog(logEntry: LogEntry): InvocationAccumulator
fun group(): LogsReport
val reports: HashMap<CodeLocation, FunctionReport>
val starts: Map<UUID, LogEntry>

io.vavr.control.Either

fun <T> Either<T, T>.merge(): T

kotlin.Function1

fun <reified T : FlexibleEnv, A> ((T) -> A).flex(): (FlexibleEnv) -> A

data class LogEntry

LogEntry(tracerName: String, uuid: UUID, time: Long, codeLocation: CodeLocation, message: EntryType)
val codeLocation: CodeLocation
val message: EntryType
val time: Long
val tracerName: String
val uuid: UUID

interface Logger<T : Logger<T>>

abstract fun log(entry: LogEntry): T

interface Logging
data class LogMessage

LogMessage(traceEntry: LogEntry)
val traceEntry: LogEntry

class LogsAnalyzer

LogsAnalyzer()
fun processLogs(logs: Seq<LogMessage>): LogsReport

interface LogsProvider

abstract fun getLogs(): Seq<LogMessage>
abstract fun getReport(): LogsReport

data class LogsReport

LogsReport(classes: Seq<ClassReport> = List.empty())
val classes: Seq<ClassReport>

class MutableInMemLogger : Logger<MutableInMemLogger>, LogsProvider

MutableInMemLogger()
fun getLogs(): Seq<LogMessage>
fun getReport(): LogsReport
fun log(entry: LogEntry): MutableInMemLogger

class NaiveCacheProvider : CacheProvider

NaiveCacheProvider()
fun <K, V> computeIfAbsent(key: K, func: (K) -> V): V

typealias NanoTime = () -> Long
sealed class Nee<R, E, out A>

fun anyError(): ANee<R, A>
fun <R, E, A : Any> constR(effect: Effect<R, E>, value: A): Nee<R, E, A>
fun <R, E, A> constWithError(effect: Effect<R, E>, func: (R) -> Out<E, A>): Nee<R, E, A>
abstract fun <B> flatMap(f: (A) -> Nee<R, E, B>): Nee<R, E, B>
fun <R, E, A, E1 : E> flatOut(f: Nee<R, E, Out<E1, A>>): <ERROR CLASS>
abstract fun <B> map(f: (A) -> B): Nee<R, E, B>
abstract fun perform(env: R): Out<E, A>
fun <R, E, A> pure(a: A): Nee<R, E, A>
fun <R, E, A> with(effect: Effect<R, E>, func: (R) -> A): Nee<R, E, A>
fun <R, E, A> withError(effect: Effect<R, E>, func: (R) -> Out<E, A>): Nee<R, E, A>

class NoEffect<R, E> : Effect<R, E>

NoEffect()
fun <R, E> get(): NoEffect<R, E>
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

sealed class Out<E, out A>

abstract fun <B> flatMap(f: (A) -> Out<E, B>): Out<E, B>
fun <E, A> fromFuture(future: Future<Either<E, A>>): Out<E, A>
fun <E, A> left(e: E): Out<E, A>
abstract fun <B> map(f: (A) -> B): Out<E, B>
abstract fun <E1> mapLeft(f: (E) -> E1): Out<E1, A>
abstract fun onComplete(f: (Either<E, out A>) -> Unit): Unit
fun <E, A> right(a: A): Out<E, A>
fun <E, A> right(future: Future<A>): Out<E, A>
abstract fun toFuture(): Future<out Either<E, out A>>

data class ResourceId<T : Any>

ResourceId(clazz: KClass<T>, key: Any = DefaultKey)
val clazz: KClass<T>
object DefaultKey
val key: Any

class SecuredRunEffect<USER, ROLE, R : SecurityProvider<USER, ROLE>> : Effect<R, SecurityError>

SecuredRunEffect(singleRole: ROLE)
SecuredRunEffect(roles: List<ROLE>)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<SecurityError, A>, R>

interface SecurityCtx<USER, ROLE>

abstract fun getCurrentUser(): Out<SecurityError, USER>
abstract fun hasRole(role: ROLE): Boolean

interface SecurityError

abstract fun secError(): SecurityErrorType

sealed class SecurityErrorType : SecurityError

data class MalformedCredentials : SecurityErrorType

MalformedCredentials(message: String = "")
val message: String

data class MissingRole<ROLE> : SecurityErrorType

MissingRole(roles: List<ROLE>)
val roles: List<ROLE>

object NoSecurityCtx : SecurityErrorType
open fun secError(): SecurityErrorType
object UnknownUser : SecurityErrorType
class WrongCredentials : SecurityErrorType

WrongCredentials(message: String = "")
val message: String

interface SecurityProvider<USER, ROLE>

abstract fun getSecurityContext(): Out<SecurityError, SecurityCtx<USER, ROLE>>

data class SimpleBufferedLogger : Logger<SimpleBufferedLogger>

SimpleBufferedLogger(buffer: Vector<LogMessage> = Vector.empty())
fun getLogs(): Seq<LogMessage>
fun log(entry: LogEntry): SimpleBufferedLogger

class SimpleTraceProvider : TraceProvider<SimpleTraceProvider>

SimpleTraceProvider(res: TraceResource)
fun getTrace(): TraceResource
val res: TraceResource
fun setTrace(newState: TraceResource): SimpleTraceProvider

class SyncExecutionContext : ExecutionContext

SyncExecutionContext()
fun <T> execute(f: () -> T): Future<T>

interface TimeProvider

abstract fun getTimeSource(): TimeSource

class TraceEffect<R : TraceProvider<R>> : Effect<R, Nothing>

TraceEffect(tracerName: String)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<Nothing, A>, R>

data class TraceEntry

TraceEntry(tracerName: String, uuid: UUID, time: Long, codeLocation: AtomicReference<CodeLocation?> = AtomicReference())
val codeLocation: AtomicReference<CodeLocation?>
fun getCodeLocation(): CodeLocation
val time: Long
val tracerName: String
val uuid: UUID

interface TraceProvider<G : TraceProvider<G>>

abstract fun getTrace(): TraceResource
abstract fun setTrace(newState: TraceResource): G

class TraceResource

TraceResource(resName: String, logger: Logger<*>, nanoTime: NanoTime = { System.nanoTime() }, traces: List<TraceEntry> = List.empty<TraceEntry>())
val logger: Logger<*>
val nanoTime: NanoTime
fun putNamedPlace(name: CodeLocation = guessCodePlaceName()): Unit
val resName: String
val traces: List<TraceEntry>

interface TxConnection<R> : Closeable

abstract fun begin(): Either<TxError, TxStarted<R>>
abstract fun continueTx(): Either<TxError, TxStarted<R>>
abstract fun getResource(): R
abstract fun hasTransaction(): Boolean

class TxEffect<DB, R : TxProvider<DB, R>> : Effect<R, TxError>, Logging

TxEffect(requiresNew: Boolean = false)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<TxError, A>, R>

interface TxError

abstract fun txError(): TxErrorType

sealed class TxErrorType : TxError

object CannotCommitTransaction : TxErrorType
object CannotContinueTransaction : TxErrorType
data class CannotQuery : TxErrorType

CannotQuery(msg: String)
val msg: String

object CannotRollbackTransaction : TxErrorType
object CannotStartTransaction : TxErrorType
data class InternalException : TxErrorType

InternalException(cause: Exception)
val cause: Exception

data class MultipleErrors : TxErrorType

MultipleErrors(errors: List<TxError>)
val errors: List<TxError>

object NoConnection : TxErrorType
open fun txError(): TxErrorType

interface TxProvider<R, G : TxProvider<R, G>>

abstract fun getConnection(): TxConnection<R>
abstract fun setConnectionState(newState: TxConnection<R>): G

interface TxStarted<R> : TxConnection<R>

abstract fun commit(): Pair<Option<TxError>, TxConnection<R>>
abstract fun rollback(): Pair<Option<TxError>, TxConnection<R>>

data class WrappedEnv<Y : Any> : FlexibleEnv

WrappedEnv(env: Y, resId: ResourceId<Y>, inner: FlexibleEnv)
fun <T : Any> get(id: ResourceId<T>): Option<T>
fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

package dev.neeffect.nee

fun <R1, E1, R2 : R1, E2> Effect<R2, E2>.andThen(otherEffect: Effect<R1, E1>): Effect<R2, Either<E1, E2>>
typealias ANee<R, A> = Nee<R, Any, A>
fun <R, E> Effect<R, E>.anyError(): Effect<R, Any>
interface Effect<R, E>

open fun <XE> handleError(handler: (E) -> XE): Effect<R, XE>
abstract fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

class Effects<R1, R2 : R1, E1, E2> : Effect<R2, Either<E1, E2>>

Effects(inner: Effect<R1, E1>, outer: Effect<R2, E2>)
fun <R1, R2 : R1, E1, E2> combine(outer: Effect<R1, E1>, inner: Effect<R2, E2>): Effect<R2, Either<E1, E2>>
fun <A> wrap(f: (R2) -> A): (R2) -> Pair<Out<Either<E1, E2>, A>, R2>

class HandleErrorEffect<R, E, E1> : Effect<R, E1>

HandleErrorEffect(innerEffect: Effect<R, E>, handler: (E) -> E1)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E1, A>, R>

sealed class Nee<R, E, out A>

fun anyError(): ANee<R, A>
fun <R, E, A : Any> constR(effect: Effect<R, E>, value: A): Nee<R, E, A>
fun <R, E, A> constWithError(effect: Effect<R, E>, func: (R) -> Out<E, A>): Nee<R, E, A>
abstract fun <B> flatMap(f: (A) -> Nee<R, E, B>): Nee<R, E, B>
fun <R, E, A, E1 : E> flatOut(f: Nee<R, E, Out<E1, A>>): <ERROR CLASS>
abstract fun <B> map(f: (A) -> B): Nee<R, E, B>
abstract fun perform(env: R): Out<E, A>
fun <R, E, A> pure(a: A): Nee<R, E, A>
fun <R, E, A> with(effect: Effect<R, E>, func: (R) -> A): Nee<R, E, A>
fun <R, E, A> withError(effect: Effect<R, E>, func: (R) -> Out<E, A>): Nee<R, E, A>

class NoEffect<R, E> : Effect<R, E>

NoEffect()
fun <R, E> get(): NoEffect<R, E>
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

fun <R, E> noEffect(): NoEffect<R, E>
operator fun <R1, E1, R2 : R1, E2 : E1> Effect<R2, E2>.plus(otherEffect: Effect<R1, E1>): Effect<R2, E1>
infix fun <R1, E1, R2 : R1, E2> Effect<R2, E2>.then(otherEffect: Effect<R1, E1>): Effect<R2, Either<E1, E2>>
infix fun <R1, E1, R2 : R1, E2 : E1> Effect<R2, E2>.with(otherEffect: Effect<R1, E1>): Effect<R2, E1>

package dev.neeffect.nee.effects

sealed class Out<E, out A>

abstract fun <B> flatMap(f: (A) -> Out<E, B>): Out<E, B>
fun <E, A> fromFuture(future: Future<Either<E, A>>): Out<E, A>
fun <E, A> left(e: E): Out<E, A>
abstract fun <B> map(f: (A) -> B): Out<E, B>
abstract fun <E1> mapLeft(f: (E) -> E1): Out<E1, A>
abstract fun onComplete(f: (Either<E, out A>) -> Unit): Unit
fun <E, A> right(a: A): Out<E, A>
fun <E, A> right(future: Future<A>): Out<E, A>
abstract fun toFuture(): Future<out Either<E, out A>>

package dev.neeffect.nee.effects.async

class ActiveAsyncClose<R>

ActiveAsyncClose(asyncClean: ActiveAsynStack<R>)
fun closeAsync(env: R): Any?

class ActiveAsynStack<R> : AsyncStack<R>

ActiveAsynStack(parent: AsyncStack<R>, actions: Seq<AsyncClosingAction<R>>)
fun cleanUp(env: R): Pair<AsyncStack<R>, R>
fun closeAsync(env: R): Pair<AsyncStack<R>, R>
fun doOnCleanUp(action: AsyncClosingAction<R>): ActiveAsynStack<R>
val parent: AsyncStack<R>

interface AsyncClosingAction<R>

abstract fun onClose(env: R): R
abstract fun onError(env: R, t: Throwable): R

class AsyncEffect<R : ExecutionContextProvider> : Effect<R, Nothing>, Logging

AsyncEffect(localExecutionContext: Option<ExecutionContext> = Option.none())
val localExecutionContext: Option<ExecutionContext>
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<Nothing, A>, R>

class AsyncEnvWrapper<R> : AsyncSupport<R>, Logging

AsyncEnvWrapper(state: AtomicReference<AsyncStack<R>> = AtomicReference(CleanAsyncStack()))
fun asyncStack(): AsyncStack<R>
fun setAsyncStack(oldState: AsyncStack<R>, newState: AsyncStack<R>): Unit

sealed class AsyncStack<R> : Logging

val actions: Seq<AsyncClosingAction<R>>
abstract fun cleanUp(env: R): Pair<AsyncStack<R>, R>
open fun doOnCleanUp(action: AsyncClosingAction<R>): ActiveAsynStack<R>
open fun enterAsync(): ActiveAsynStack<R>
protected fun performActions(env: R): R

interface AsyncSupport<R>

val asyncResouce: ResourceId<AsyncStack<*>>
abstract fun asyncStack(): AsyncStack<R>
fun <R> initiateAsync(env: R): ActiveAsyncClose<R>
abstract fun setAsyncStack(oldState: AsyncStack<R>, newState: AsyncStack<R>): Unit

class CleanAsyncStack<R> : AsyncStack<R>

CleanAsyncStack()
fun cleanUp(env: R): Pair<AsyncStack<R>, R>

fun <R> doNothing(env: R): R
class ECProvider : ExecutionContextProvider

ECProvider(ectx: ExecutionContext, localWins: Boolean = true)
fun findExecutionContext(local: Option<ExecutionContext>): ExecutionContext

fun <R, T> executeAsyncCleaning(env: R, action: () -> T, cleanAction: (R) -> R): T
interface ExecutionContext

abstract fun <T> execute(f: () -> T): Future<T>

interface ExecutionContextProvider

abstract fun findExecutionContext(local: Option<ExecutionContext>): ExecutionContext

class ExecutorExecutionContext : ExecutionContext, Logging

ExecutorExecutionContext(executor: Executor)
fun <T> execute(f: () -> T): Future<T>

object InPlaceExecutor : Executor

fun execute(command: Runnable): Unit

fun <R> AsyncStack<R>.onClose(f: (R) -> R): ActiveAsynStack<R>
class SyncExecutionContext : ExecutionContext

SyncExecutionContext()
fun <T> execute(f: () -> T): Future<T>

package dev.neeffect.nee.effects.cache

class CacheEffect<R, E, P> : Effect<R, E>

CacheEffect(p: P, cacheProvider: CacheProvider)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<E, A>, R>

interface CacheProvider

abstract fun <K, V> computeIfAbsent(key: K, func: (K) -> V): V

class NaiveCacheProvider : CacheProvider

NaiveCacheProvider()
fun <K, V> computeIfAbsent(key: K, func: (K) -> V): V

package dev.neeffect.nee.effects.env

object EnvLeaf : FlexibleEnv

fun <T : Any> get(id: ResourceId<T>): Option<T>
fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

interface FlexibleEnv

fun <reified T : Any> create(id: ResourceId<T>, t: T): FlexibleEnv
fun <reified T : Any> create(t: T): FlexibleEnv
fun empty(): FlexibleEnv
abstract fun <T : Any> get(id: ResourceId<T>): Option<T>
abstract fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

data class ResourceId<T : Any>

ResourceId(clazz: KClass<T>, key: Any = DefaultKey)
val clazz: KClass<T>
object DefaultKey
val key: Any

fun <reified T : Any> FlexibleEnv.with(t: T): FlexibleEnv
fun <reified T : Any> FlexibleEnv.with(id: ResourceId<T>, t: T): FlexibleEnv
data class WrappedEnv<Y : Any> : FlexibleEnv

WrappedEnv(env: Y, resId: ResourceId<Y>, inner: FlexibleEnv)
fun <T : Any> get(id: ResourceId<T>): Option<T>
fun <T : Any> set(id: ResourceId<T>, t: T): FlexibleEnv

package dev.neeffect.nee.effects.monitoring

data class ClassReport

ClassReport(className: String, functions: Stream<FunctionReport>)
val className: String
val functions: Stream<FunctionReport>

data class CodeLocation

CodeLocation(functionName: String? = null, className: String? = null, fileName: String? = null, lineNumber: Int? = null, customInfo: String? = null)
val className: String?
val customInfo: String?
val fileName: String?
val functionName: String?
val lineNumber: Int?
fun toString(): String

object CodeNameFinder

fun findBestStackMatchingCodePlaceName(suggestedStackPosition: Int, stackTraces: Array<StackTraceElement>): CodeLocation
fun guessCodePlaceName(suggestedStackPosition: Int = 3): CodeLocation

sealed class EntryType

object Begin : EntryType
data class End : EntryType

End(elapsedTime: Long)
val elapsedTime: Long

data class InternalError : EntryType

InternalError(msg: String)
val msg: String
fun toString(): String

data class FunctionReport

FunctionReport(codeLocation: CodeLocation, invocationCount: Long, totalTime: Long, errorsCount: Long)
val codeLocation: CodeLocation
val errorsCount: Long
val invocationCount: Long
operator fun plus(other: FunctionReport): FunctionReport
val totalTime: Long

data class InvocationAccumulator

InvocationAccumulator(starts: Map<UUID, LogEntry> = HashMap.empty(), reports: HashMap<CodeLocation, FunctionReport> = HashMap.empty())
fun addLog(logEntry: LogEntry): InvocationAccumulator
fun group(): LogsReport
val reports: HashMap<CodeLocation, FunctionReport>
val starts: Map<UUID, LogEntry>

data class LogEntry

LogEntry(tracerName: String, uuid: UUID, time: Long, codeLocation: CodeLocation, message: EntryType)
val codeLocation: CodeLocation
val message: EntryType
val time: Long
val tracerName: String
val uuid: UUID

interface Logger<T : Logger<T>>

abstract fun log(entry: LogEntry): T

data class LogMessage

LogMessage(traceEntry: LogEntry)
val traceEntry: LogEntry

class LogsAnalyzer

LogsAnalyzer()
fun processLogs(logs: Seq<LogMessage>): LogsReport

interface LogsProvider

abstract fun getLogs(): Seq<LogMessage>
abstract fun getReport(): LogsReport

data class LogsReport

LogsReport(classes: Seq<ClassReport> = List.empty())
val classes: Seq<ClassReport>

class MutableInMemLogger : Logger<MutableInMemLogger>, LogsProvider

MutableInMemLogger()
fun getLogs(): Seq<LogMessage>
fun getReport(): LogsReport
fun log(entry: LogEntry): MutableInMemLogger

typealias NanoTime = () -> Long
data class SimpleBufferedLogger : Logger<SimpleBufferedLogger>

SimpleBufferedLogger(buffer: Vector<LogMessage> = Vector.empty())
fun getLogs(): Seq<LogMessage>
fun log(entry: LogEntry): SimpleBufferedLogger

class SimpleTraceProvider : TraceProvider<SimpleTraceProvider>

SimpleTraceProvider(res: TraceResource)
fun getTrace(): TraceResource
val res: TraceResource
fun setTrace(newState: TraceResource): SimpleTraceProvider

class TraceEffect<R : TraceProvider<R>> : Effect<R, Nothing>

TraceEffect(tracerName: String)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<Nothing, A>, R>

data class TraceEntry

TraceEntry(tracerName: String, uuid: UUID, time: Long, codeLocation: AtomicReference<CodeLocation?> = AtomicReference())
val codeLocation: AtomicReference<CodeLocation?>
fun getCodeLocation(): CodeLocation
val time: Long
val tracerName: String
val uuid: UUID

interface TraceProvider<G : TraceProvider<G>>

abstract fun getTrace(): TraceResource
abstract fun setTrace(newState: TraceResource): G

class TraceResource

TraceResource(resName: String, logger: Logger<*>, nanoTime: NanoTime = { System.nanoTime() }, traces: List<TraceEntry> = List.empty<TraceEntry>())
val logger: Logger<*>
val nanoTime: NanoTime
fun putNamedPlace(name: CodeLocation = guessCodePlaceName()): Unit
val resName: String
val traces: List<TraceEntry>

package dev.neeffect.nee.effects.security

class FlexSecEffect<USER, ROLE> : Effect<FlexibleEnv, SecurityError>

FlexSecEffect(roles: List<ROLE>)
fun <A> wrap(f: (FlexibleEnv) -> A): (FlexibleEnv) -> Pair<Out<SecurityError, A>, FlexibleEnv>

class FlexSecurityProvider<USER, ROLE> : FlexibleEnv, SecurityProvider<USER, ROLE>

FlexSecurityProvider(env: FlexibleEnv)
fun getSecurityContext(): Out<SecurityError, SecurityCtx<USER, ROLE>>

class SecuredRunEffect<USER, ROLE, R : SecurityProvider<USER, ROLE>> : Effect<R, SecurityError>

SecuredRunEffect(singleRole: ROLE)
SecuredRunEffect(roles: List<ROLE>)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<SecurityError, A>, R>

interface SecurityCtx<USER, ROLE>

abstract fun getCurrentUser(): Out<SecurityError, USER>
abstract fun hasRole(role: ROLE): Boolean

interface SecurityError

abstract fun secError(): SecurityErrorType

sealed class SecurityErrorType : SecurityError

data class MalformedCredentials : SecurityErrorType

MalformedCredentials(message: String = "")
val message: String

data class MissingRole<ROLE> : SecurityErrorType

MissingRole(roles: List<ROLE>)
val roles: List<ROLE>

object NoSecurityCtx : SecurityErrorType
open fun secError(): SecurityErrorType
object UnknownUser : SecurityErrorType
class WrongCredentials : SecurityErrorType

WrongCredentials(message: String = "")
val message: String

interface SecurityProvider<USER, ROLE>

abstract fun getSecurityContext(): Out<SecurityError, SecurityCtx<USER, ROLE>>

package dev.neeffect.nee.effects.test

fun <E, A> Out<E, A>.get(): A
fun <E, A> Out<E, A>.getAny(): Either<E, A>
fun <E, A> Out<E, A>.getLeft(): E

package dev.neeffect.nee.effects.time

class HasteTimeProvider : TimeProvider

HasteTimeProvider(timeSource: TimeSource = Haste.TimeSource.systemTimeSource())
fun getTimeSource(): TimeSource

interface TimeProvider

abstract fun getTimeSource(): TimeSource

package dev.neeffect.nee.effects.tx

class FlexTxEffect<R> : Effect<FlexibleEnv, TxError>

FlexTxEffect()
fun <A> wrap(f: (FlexibleEnv) -> A): (FlexibleEnv) -> Pair<Out<TxError, A>, FlexibleEnv>

kotlin.Function1

fun <reified T : FlexibleEnv, A> ((T) -> A).flex(): (FlexibleEnv) -> A

interface TxConnection<R> : Closeable

abstract fun begin(): Either<TxError, TxStarted<R>>
abstract fun continueTx(): Either<TxError, TxStarted<R>>
abstract fun getResource(): R
abstract fun hasTransaction(): Boolean

class TxEffect<DB, R : TxProvider<DB, R>> : Effect<R, TxError>, Logging

TxEffect(requiresNew: Boolean = false)
fun <A> wrap(f: (R) -> A): (R) -> Pair<Out<TxError, A>, R>

interface TxError

abstract fun txError(): TxErrorType

sealed class TxErrorType : TxError

object CannotCommitTransaction : TxErrorType
object CannotContinueTransaction : TxErrorType
data class CannotQuery : TxErrorType

CannotQuery(msg: String)
val msg: String

object CannotRollbackTransaction : TxErrorType
object CannotStartTransaction : TxErrorType
data class InternalException : TxErrorType

InternalException(cause: Exception)
val cause: Exception

data class MultipleErrors : TxErrorType

MultipleErrors(errors: List<TxError>)
val errors: List<TxError>

object NoConnection : TxErrorType
open fun txError(): TxErrorType

interface TxProvider<R, G : TxProvider<R, G>>

abstract fun getConnection(): TxConnection<R>
abstract fun setConnectionState(newState: TxConnection<R>): G

interface TxStarted<R> : TxConnection<R>

abstract fun commit(): Pair<Option<TxError>, TxConnection<R>>
abstract fun rollback(): Pair<Option<TxError>, TxConnection<R>>

fun <R, G : TxProvider<R, G>> FlexibleEnv.withTxProvider(provider: TxProvider<R, G>): FlexibleEnv

package dev.neeffect.nee.effects.utils

fun invalid(): Nothing
io.vavr.control.Either

fun <T> Either<T, T>.merge(): T

fun <reified T : Logging> T.logger(): Logger
interface Logging
fun <ENV, A, B, R> tupled(f: (ENV) -> (A, B) -> R): (ENV) -> (Tuple2<A, B>) -> R
fun <ENV, A, B, R> tupled2(f: (ENV) -> (A, B) -> R): (ENV) -> (Tuple2<A, B>) -> R
fun <ENV, A, B, C, R> tupled3(f: (ENV) -> (A, B, C) -> R): (ENV) -> (Tuple3<A, B, C>) -> R