{@inheritdoc}

@param string|array $fallback

@return $this
18727
public function setFallbacks($fallback)
    {
        $this->localeFallbacks = (array)$fallback;
        if ($this->coreFormatter instanceof Multilingual) {
            $this->coreFormatter->setFallbacks($this->localeFallbacks);
        }
        if ($this->textProvider instanceof Multilingual) {
            $this->textProvider->setFallbacks($this->localeFallbacks);
        }
        return $this;
    }
1218107
public function secret($question, $fallback = true)
    {
        $question = new Question($question);

        $question->setHidden(true)->setHiddenFallback($fallback);

        return $this->output->askQuestion($question);
    }
815454
public function setFallbackUrl(string $fallbackUrl): self
    {
        $this->isValidUrl($fallbackUrl);

        $this->fallbackUrl = $fallbackUrl;

        return $this;
    }
186826
public function setFilterFunction($callback)
    {
        if (!is_callable($callback, true)) {
            throw new InvalidArgumentException('TreeDropdownField->setFilterCallback(): not passed a valid callback');
        }

        $this->filterCallback = $callback;
        return $this;
    }
1302295
public static function get(array $array, $key, $fallback = null)
    {
        $keys = explode('.', $key);
        foreach($keys as $key) {
            if(!isset($array[$key])) {
                return $fallback;
            }
            $array = $array[$key];
        }

        return $array;
    }
1340228
public function getCacheFallback()
    {
        $fallback = $this->fallback;

        return $this->getCacheSystem()->getOrCreateFile('fallback.jpg', array(), function ($target) use ($fallback) {
            copy($fallback, $target);
        });
    }
1122188
def set_default(fallback)
      if valid_fallback?(fallback) || fallback == NO_DEFAULT
        @default = fallback
      else
        raise InvalidFallback, "Cannot set #{fallback.inspect} as default", caller
      end
    end
1017063
public function set($callback, $args = [])
    {
        if ($this->postTrigger) {
            if (isset($_POST[$this->postTrigger])) {
                $this->app->catch_runaway_callbacks = false;
                $this->triggered = $_POST[$this->postTrigger];

                $t = $this->app->run_called;
                $this->app->run_called = true;
                $ret = call_user_func_array($callback, $args);
                $this->app->run_called = $t;

                return $ret;
            }
        } else {
            if (isset($_GET[$this->urlTrigger])) {
                $this->app->catch_runaway_callbacks = false;
                $this->triggered = $_GET[$this->urlTrigger];

                $t = $this->app->run_called;
                $this->app->run_called = true;
                $this->owner->stickyGet($this->urlTrigger);
                $ret = call_user_func_array($callback, $args);
                //$this->app->stickyForget($this->name);
                $this->app->run_called = $t;

                return $ret;
            }
        }
    }
342972
public function setSearchFunction($callback)
    {
        if (!is_callable($callback, true)) {
            throw new InvalidArgumentException('TreeDropdownField->setSearchFunction(): not passed a valid callback');
        }

        $this->searchCallback = $callback;
        return $this;
    }
1046349
public function each(callable $callback): self
    {
        $index = 0;
        foreach ($this->items as $key => $value) {
            $callback($value, $key, $index++);
        }

        return $this;
    }
787482
public function translate($language = null, $fallback = true)
    {
        if ($this->relationLoaded('translations')) {
            $this->load('translations');
        }

        return (new Translator($this))->translate($language, $fallback);
    }
386915
public function previous($fallback = false)
    {
        $referrer = $this->request->headers->get('referer');

        $url = $referrer ? $this->to($referrer) : $this->getPreviousUrlFromSession();

        if ($url) {
            return $url;
        } elseif ($fallback) {
            return $this->to($fallback);
        }

        return $this->to('/');
    }
1184438
public function setCallback($callback)
    {
        if($callback instanceof Closure)
        {
            $this->callback = $callback;
        }
        elseif(is_callable($callback))
        {
            $this->callback = function($chunk) use($callback)
            {
                return call_user_func_array($callback, [$chunk]);
            };
        }
        else
        {
            throw new Exception('Invalid callback');
        }

        return $this;
    }
381535
public function use_fallback($boolean = NULL)
	{
		if ($boolean === NULL)
		{
			return $this->_use_fallback;
		}
		$this->_use_fallback = $boolean;
		return $this;
	}
1307182
public function set($type, $path)
    {
        if ($path instanceof pathmanager\FallbackInterface) {
            $this->paths[$type] = $path;
            return $this;
        }

        if (is_array($path)) {
            if (isset($this->paths[$type])) {
                $fallback = $this->paths[$type];
                if (!$fallback instanceof pathmanager\FallbackInterface) {
                    $first = $fallback;
                    $fallback = new pathmanager\DefaultFallback();
                    $fallback->addPath($first);
                }
            } else {
                $fallback = new pathmanager\DefaultFallback();
            }

            $this->paths[$type] = $fallback;
            foreach ($path as $item) {
                $this->set($type, $item);
            }

            return $this;
        }

        $path = $this->prepare($path);

        if (isset($this->paths[$type]) && ($this->paths[$type] instanceof pathmanager\FallbackInterface)) {
            $this->paths[$type]->addPath($path);
        } else {
            $this->paths[$type] = $path;
        }

        return $this;
    }
1235819
public function each($callback)  
    {
        Eden_Array_Argument::i()->test(1, 'callable');

        foreach ($this->data as $key => $value) {
            call_user_func($callback, $key, $value);
        }

        return $this;
    }
412224
final public function pipe(callable $stage, callable $fallback = null): PipeChainInterface
    {
        $this->stack->attach($stage, $fallback);

        return $this;
    }