JonCatmull

  /**
   * Stores last emitted value in localStorage and replays if usStore$ is set.
   * If usStore$ is truthy then switches stream to use stored value.
   * If usStore$ is undefined then stream will emit as normal.
   * @param storageKey unique key to use in localStorage
   * @param useStore$ controls if the localStorage value is used
   */
  export default function localStorageReplay<T>(storageKey: string, useStore$: BehaviorSubject<boolean>): MonoTypeOperatorFunction<T> {
    return (input$): Observable<T> => {

kakai248

// ViewModel factory

@MainThread
inline fun <reified VM : ViewModel> ComponentActivity.viewModel(
    noinline provider: (SavedStateHandle) -> VM
) = createLazyViewModel(
    viewModelClass = VM::class,
    savedStateRegistryOwnerProducer = { this },
    viewModelStoreOwnerProducer = { this },
    viewModelProvider = provider

androidfred

Kotlin Arrow

A lot of Kotlin features can be traced back to functional programming languages, eg

• Heavy use of immutability-by-default and map, filter etc functions
• Type inference
• Data classes (which enable pattern matching)
• Null safety and dealing with the absence of values

However, Kotlin is missing many incredibly useful data types that are ubiquitous in functional programming languages, eg Either, Try etc.

swlaschin

Tips on exposing F# to C#

Api and Methods

I suggest that you create one or more Api.fs files to expose F# code in a C# friendly way.

In this file:

• Define functions with PascalCase names. They will appear to C# as static methods.
• Functions should use tuple-style declarations (like C#) rather than F#-style params with spaces.

Viska97

class TestBoundaryCallback(
    private val pageSize: Int,
    private val dataSource: BackendDataSource,
    private val database : AppDatabase
) : PagedList.BoundaryCallback<?>(){

    var networkState = MutableLiveData<Int>()

    private var isRequestInProgress = false

felix19350

package org.example

import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import io.ktor.application.call
import io.ktor.http.HttpStatusCode
import io.ktor.request.receive
import io.ktor.response.respond
import io.ktor.routing.Route
import io.ktor.routing.get

JoseAlcerreca

/**
 * An [Observer] for [Event]s, simplifying the pattern of checking if the [Event]'s content has
 * already been handled.
 *
 * [onEventUnhandledContent] is *only* called if the [Event]'s contents has not been handled.
 */
class EventObserver<T>(private val onEventUnhandledContent: (T) -> Unit) : Observer<Event<T>> {
    override fun onChanged(event: Event<T>?) {
        event?.getContentIfNotHandled()?.let { value ->
            onEventUnhandledContent(value)

santrancisco

# -*- mode: ruby -*-
# vi: set ft=ruby :

## Thanks to the discussion of various developers in this gist
## https://gist.github.com/andreptb/57e388df5e881937e62a#gistcomment-2346821
## Especially clement-igonet.

### How to get Windows10 with Edge official base image run with WinRM and RDP:
# To use Windows10-Edge vagrant you will first need to download https://aka.ms/msedge.win10.vagrant (this is now a zip file)
# Execute `vagrant box add ./MsEdge\ -\ Win10.box --name Win10-official` after unzip the file to add the box to our base image list

ckimrie

import { Component, OnInit, OnDestroy } from '@angular/core';
import {Http} from "@angular/http";
import { LocalCacheService } from "./local-cache.service";

@Component({
  selector: 'app-example',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class ExampleComponent implements OnInit, OnDestroy {

btroncone

//specify what state slices you would like to keep synced with local storage
export function main() {
  return bootstrap(TodoApp, [
      provideStore(APP_REDUCERS),
      localStorageMiddleware('todos', 'visibilityFilter')
  ])
  .catch(err => console.error(err));
}