Peek at the current value of the Maybe
<pre>
{@code
MaybeWT.of(AnyM.fromStream(Arrays.asMaybeW(10))
.peek(System.out::println);

//prints 10
}
</pre>

@param peek  Consumer to accept current value of Maybe
@return MaybeWT with peek call
778278
@Override
    public EitherT<W,ST,T> peek(final Consumer<? super T> peek) {
        return map(e->{
            peek.accept(e);
            return e;
        });
    }
1076408
public int peekChar() throws IOException {
	
	// load more characters, if needed
	if (fCurrentEntity.position == fCurrentEntity.count) {
	    load(0, true);
	}
	
	// peek at character
	int c = fCurrentEntity.ch[fCurrentEntity.position];

	// return peeked character
	if (fCurrentEntity.isExternal()) {
	    return c != '\r' ? c : '\n';
	}
	else {
	    return c;
	}
	
    }
433673
@Override
    public int peek(int offset) throws IOException
    {
        long target = cursor + offset - 1;
        if (target - end > size || target < end - size || target < 0)
        {
            throw new IllegalArgumentException("offset "+offset+" out of buffer");
        }
        if (target >= end)
        {
            int la = 0;
            while (target >= end)
            {
                int cc = read();
                if (cc == -1)
                {
                    if (target+la == end)
                    {
                        return -1;
                    }
                    else
                    {
                        throw new IOException("eof");
                    }
                }
                la++;
            }
            rewind(la);
        }
        return get(target);
    }
1056298
private Scope peek() throws JSONException {
		if (this.stack.isEmpty()) {
			throw new JSONException("Nesting problem");
		}
		return this.stack.get(this.stack.size() - 1);
	}
220449
public Val nextValue() throws IOException {
      switch (peek()) {
         case BEGIN_ARRAY:
            return Val.of(nextCollection(ArrayList::new));
         case BEGIN_OBJECT:
            return Val.of(nextMap());
         case NAME:
            return nextKeyValue().getV2();
         default:
            return nextSimpleValue();
      }
   }
284329
public Either<L, R> peek(Consumer<R> rightConsumer) {
        return Peek.peek(rightConsumer, this);
    }
24242
private T pollInternal(boolean peek) {
        this.writeLock.lock();
        try {
            // Re-check size within the write lock
            if (this.size == 0) {
                return null;
            }

            final K key;
            if (this.peekedKey != null) {
                // If there is a peeked key use it
                key = this.peekedKey;
                if (!peek) {
                    // If not a peek consume the peekedKey
                    this.peekedKey = null;
                }
            } else {
                // Get the next element key
                key = this.getNextElementKey();
                if (peek) {
                    // If a peek store the key
                    this.peekedKey = key;
                }
            }

            // Get the associated Queue and sanitity check the value from getNextElementKey()
            final Queue<T> queue = this.keyedQueues.get(key);
            if (queue == null || queue.isEmpty()) {
                throw new IllegalStateException(
                        "getNextElementKey returned key='"
                                + key
                                + "' but there are no elements available for the key. This violates the contract specified for getNextElementKey");
            }

            if (peek) {
                // If a peek just return a peek from the queue
                return queue.peek();
            }

            // Not a peek, decrement the size and poll the queue
            this.size--;
            this.notFull.signal();
            return queue.poll();
        } finally {
            this.writeLock.unlock();
        }
    }
326200
public SIBusMessage peek() throws SISessionUnavailableException, SIIncorrectCallException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "peek", this);

    checkValidState("peek");

    localConsumerPoint.checkNotClosed();

    JsMessage jsMsg = null;

    synchronized(this)
    {
      if(!endReached)
      {
        // If currentMsg is null it means we start from the begining
        if(currentMsg == null)
        {
          if(firstMsg != null)
          {
            jsMsg = setPropertiesInMessage(firstMsg);
          }
        }
        else
        {
          if(currentMsg.next != null)
          {
            jsMsg = setPropertiesInMessage(currentMsg.next);
          }
        }
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "peek", jsMsg);
    return jsMsg;
  }
149730
@Override
    public E peek() {
        @SuppressWarnings("unchecked") E result = (E) elements[head];
        // elements[head] is null if queue empty
        return result;
    }
771135
private int bufferedPeek(final int offset) throws IOException {
    if (buffer.size() > offset) {
      // We've got enough of the file in memory already, we just pull from the buffer
      final ListIterator<Integer> iterator = buffer.listIterator(offset);
      return iterator.next();
    }
    // We don't have enough in the buffer to peek... Read until we do, then recurse.
    while (buffer.size() <= offset) {
      final int current = in.read();
      if (current < 0)
        return -1;
      buffer.add(current);
    }
    // Buffer should now be full enough to answer the request.
    return bufferedPeek(offset);
  }
1063065
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
1271981
@CheckReturnValue
    public Maybe<E> maybe() {
        return Maybe.fromCallable(new Callable<E>() {
            @Override
            public E call() throws Exception {
                return firstOrNull();
            }
        });
    }
387082
public void peekExpect(final char expectedChar) throws ParseException {
        if (position == string.length()) {
            throw new ParseException(this, "Expected '" + expectedChar + "'; reached end of string");
        }
        final char next = string.charAt(position);
        if (next != expectedChar) {
            throw new ParseException(this, "Expected '" + expectedChar + "'; got '" + next + "'");
        }
    }
14387
@Override
    public StreamT<W,T> peek(final Consumer<? super T> peek) {
        return map(a -> {
            peek.accept(a);
            return a;
        });

    }
1349168
public final <T> T nextValue(@NonNull Class<T> clazz) throws IOException {
      if (JsonSerializable.class.isAssignableFrom(clazz)) {
         return readReadable(clazz);
      } else if (peek() == JsonTokenType.BEGIN_OBJECT) {
         Reflect reflected = Reflect.onClass(clazz);
         Optional<Method> staticRead = reflected.getMethods("read", 1).stream()
                                                .filter(m -> JsonReader.class.isAssignableFrom(
                                                   m.getParameterTypes()[0]))
                                                .filter(m -> Modifier.isStatic(m.getModifiers()))
                                                .findFirst();

         if (staticRead.isPresent()) {
            try {
               beginObject();
               T result = Cast.as(staticRead.get().invoke(null, this));
               endObject();
               return result;
            } catch (IllegalAccessException | InvocationTargetException e) {
               throw new IOException(e);
            }
         }

         try {
            T object = Reflect.onClass(clazz).create().get();
            beginObject();
            new BeanMap(object).putAll(nextMap());
            endObject();
            return object;
         } catch (ReflectionException e) {
            throw new IOException(e);
         }
      }
      return nextValue().as(clazz);
   }
118765
private char peek(int offset) {
    return _x + offset < _str.length() ? _str.charAt(_x + offset) : ' ';
  }
974287
function peek(p) {
    var i = p || 0, j = 0, t;

    while (j <= i) {
      t = lookahead[j];
      if (!t) {
        t = lookahead[j] = lex.token();
      }
      j += 1;
    }
    return t;
  }